@neilberkman/sidereon 0.12.0 → 0.14.0

package/pkg-node/sidereon.js

@@ -884,6 +884,43 @@ class BroadcastEphemeris {
         const ret = wasm.broadcastephemeris_leapSeconds(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Query ECEF position and clock for parallel satellite and epoch arrays
+     * against this parsed broadcast ephemeris store.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 in GPST for GNSS broadcast records. The returned
+     * plain object has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.broadcastephemeris_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and clock for many satellites at one epoch against
+     * this parsed broadcast ephemeris store.
+     *
+     * `epochJ2000S` is seconds since J2000 in GPST. The returned object follows
+     * the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.broadcastephemeris_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Number of usable GPS, Galileo, and BeiDou records.
      * @returns {number}
@@ -4761,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.
@@ -8221,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)`.
@@ -11049,6 +11196,160 @@ class PppFloatSolution {
 if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolution.prototype.free;
 exports.PppFloatSolution = PppFloatSolution;
 
+/**
+ * A reusable precise-ephemeris interpolant with cached per-satellite nodes.
+ *
+ * Build this handle once from a parsed [`Sp3`] product, raw precise samples, or
+ * a [`PreciseEphemerisSampleSource`], then reuse it for many state or range
+ * queries. The handle delegates to
+ * `sidereon_core::ephemeris::PreciseEphemerisInterpolant`; ECEF positions are
+ * metres, clocks are seconds, and query epochs are seconds since J2000 in the
+ * source time scale.
+ */
+class PreciseEphemerisInterpolant {
+    static __wrap(ptr) {
+        const obj = Object.create(PreciseEphemerisInterpolant.prototype);
+        obj.__wbg_ptr = ptr;
+        PreciseEphemerisInterpolantFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreciseEphemerisInterpolantFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_preciseephemerisinterpolant_free(ptr, 0);
+    }
+    /**
+     * Build a cached interpolant from an existing sample-backed precise source.
+     * @param {PreciseEphemerisSampleSource} source
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromPreciseEphemerisSamples(source) {
+        _assertClass(source, PreciseEphemerisSampleSource);
+        const ret = wasm.preciseephemerisinterpolant_fromPreciseEphemerisSamples(source.__wbg_ptr);
+        return PreciseEphemerisInterpolant.__wrap(ret);
+    }
+    /**
+     * Build a cached interpolant directly from precise samples.
+     *
+     * `samples` is the same array accepted by
+     * [`preciseEphemerisSamplesFromSamples`]: each item has `{ sat, epoch,
+     * positionEcefM, clockS?, clockEvent? }`, with epochs in seconds since
+     * J2000 and positions in ECEF metres. Throws a `TypeError` for malformed
+     * JS input and a `RangeError` for sample validation failures.
+     * @param {any} samples
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromSamples(samples) {
+        const ret = wasm.preciseephemerisinterpolant_fromSamples(samples);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PreciseEphemerisInterpolant.__wrap(ret[0]);
+    }
+    /**
+     * Build a cached interpolant from a parsed SP3 precise product.
+     *
+     * Nodes are copied from the product's native SP3 records. Query epochs are
+     * seconds since J2000 in the SP3 product time scale.
+     * @param {Sp3} sp3
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromSp3(sp3) {
+        _assertClass(sp3, Sp3);
+        const ret = wasm.preciseephemerisinterpolant_fromSp3(sp3.__wbg_ptr);
+        return PreciseEphemerisInterpolant.__wrap(ret);
+    }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays using this cached interpolant.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 on this handle's time scale. The returned plain
+     * object has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.preciseephemerisinterpolant_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * using this cached interpolant.
+     *
+     * `epochJ2000S` is seconds since J2000 on this handle's time scale. The
+     * returned object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.preciseephemerisinterpolant_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Predict geometric ranges for many `(satellite, receiver, epoch)`
+     * requests using this cached interpolant.
+     *
+     * `requests` is an array of `{ sat, receiverEcefM, tRxJ2000S }` objects.
+     * Positions are ECEF metres and epochs are seconds since J2000 on this
+     * handle's time scale. The output matches [`Sp3.predictRanges`].
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerisinterpolant_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Satellite tokens this handle can interpolate, ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerisinterpolant_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Source time-scale abbreviation used by this handle's J2000-second axis,
+     * such as `"GPST"`.
+     * @returns {string}
+     */
+    get timeScale() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preciseephemerisinterpolant_timeScale(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);
+        }
+    }
+}
+if (Symbol.dispose) PreciseEphemerisInterpolant.prototype[Symbol.dispose] = PreciseEphemerisInterpolant.prototype.free;
+exports.PreciseEphemerisInterpolant = PreciseEphemerisInterpolant;
+
 /**
  * A precise-ephemeris source built from samples rather than parsed SP3 text.
  *
@@ -11073,6 +11374,44 @@ class PreciseEphemerisSampleSource {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_preciseephemerissamplesource_free(ptr, 0);
     }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays against this sample-backed precise source.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 on the source time scale. The returned plain object
+     * has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays. Failed elements use the core missing-position
+     * sentinel and carry the scalar engine error in `elementResults[i].error`.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.preciseephemerissamplesource_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * against this sample-backed precise source.
+     *
+     * `epochJ2000S` is seconds since J2000 on the source time scale. The
+     * returned plain object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.preciseephemerissamplesource_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Predict geometric ranges for many requests in one call. See the shared
      * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
@@ -12328,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}
      */
@@ -12359,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;
@@ -12415,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}
      */
@@ -12436,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}
      */
@@ -13142,6 +13535,44 @@ class Sp3 {
         }
         return Sp3Interpolation.__wrap(ret[0]);
     }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays against this parsed SP3 product.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 in the product time scale. The returned plain object
+     * has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays. Failed elements use the core missing-position
+     * sentinel and carry the scalar engine error in `elementResults[i].error`.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.sp3_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * against this parsed SP3 product.
+     *
+     * `epochJ2000S` is seconds since J2000 in the product time scale. The
+     * returned object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.sp3_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -14450,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}
@@ -14460,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}
@@ -15915,6 +16373,82 @@ function allanDeviation(series, tau0_s, averaging_factors) {
 }
 exports.allanDeviation = allanDeviation;
 
+/**
+ * Alpha-beta measurement update applied to a predicted scalar state.
+ *
+ * `predicted` is `{ level, rate }`, `measurement` has the same unit as
+ * `level`, `dt` is seconds, and `gains` is `{ alpha, beta }`.
+ * @param {any} predicted
+ * @param {number} measurement
+ * @param {number} dt
+ * @param {any} gains
+ * @returns {any}
+ */
+function alphaBetaApplyMeasurement(predicted, measurement, dt, gains) {
+    const ret = wasm.alphaBetaApplyMeasurement(predicted, measurement, dt, gains);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaApplyMeasurement = alphaBetaApplyMeasurement;
+
+/**
+ * Run one alpha-beta predict and measurement update.
+ *
+ * `state` is `{ level, rate }`, `measurement` has the same unit as `level`,
+ * `dt` is seconds, and `gains` is `{ alpha, beta }`. Returns `{ predicted,
+ * updated, innovation }`.
+ * @param {any} state
+ * @param {number} measurement
+ * @param {number} dt
+ * @param {any} gains
+ * @returns {any}
+ */
+function alphaBetaFilterStep(state, measurement, dt, gains) {
+    const ret = wasm.alphaBetaFilterStep(state, measurement, dt, gains);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaFilterStep = alphaBetaFilterStep;
+
+/**
+ * Alpha-beta constant-rate prediction.
+ *
+ * `state` is `{ level, rate }` and `dt` is the positive propagation interval in
+ * seconds. Returns the predicted `{ level, rate }`.
+ * @param {any} state
+ * @param {number} dt
+ * @returns {any}
+ */
+function alphaBetaPredict(state, dt) {
+    const ret = wasm.alphaBetaPredict(state, dt);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaPredict = alphaBetaPredict;
+
+/**
+ * Steady-state alpha-beta gains from a positive tracking index.
+ *
+ * Returns `{ alpha, beta }`, where `alpha` is the level gain and `beta` maps
+ * innovation to rate through `beta * innovation / dt`.
+ * @param {number} tracking_index
+ * @returns {any}
+ */
+function alphaBetaSteadyStateGains(tracking_index) {
+    const ret = wasm.alphaBetaSteadyStateGains(tracking_index);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaSteadyStateGains = alphaBetaSteadyStateGains;
+
 /**
  * On-sky angle in degrees between two direction vectors.
  * @param {Float64Array} a
@@ -16187,6 +16721,92 @@ function carrierFrequencyHz(system, band) {
 }
 exports.carrierFrequencyHz = carrierFrequencyHz;
 
+/**
+ * CA-CFAR false alarm probability from searched-cell count, absolute
+ * threshold, and mean noise level.
+ * @param {number} searched_cells
+ * @param {number} threshold
+ * @param {number} noise_level
+ * @returns {number}
+ */
+function cfarCaFalseAlarmProbability(searched_cells, threshold, noise_level) {
+    const ret = wasm.cfarCaFalseAlarmProbability(searched_cells, threshold, noise_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaFalseAlarmProbability = cfarCaFalseAlarmProbability;
+
+/**
+ * CA-CFAR threshold multiplier from searched-cell count and target false alarm
+ * probability.
+ * @param {number} searched_cells
+ * @param {number} false_alarm_probability
+ * @returns {number}
+ */
+function cfarCaMultiplierFromPfa(searched_cells, false_alarm_probability) {
+    const ret = wasm.cfarCaMultiplierFromPfa(searched_cells, false_alarm_probability);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaMultiplierFromPfa = cfarCaMultiplierFromPfa;
+
+/**
+ * CA-CFAR false alarm probability from searched-cell count and multiplier.
+ * @param {number} searched_cells
+ * @param {number} multiplier
+ * @returns {number}
+ */
+function cfarCaPfaFromMultiplier(searched_cells, multiplier) {
+    const ret = wasm.cfarCaPfaFromMultiplier(searched_cells, multiplier);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaPfaFromMultiplier = cfarCaPfaFromMultiplier;
+
+/**
+ * CA-CFAR absolute threshold from searched-cell count, target false alarm
+ * probability, and mean noise level.
+ * @param {number} searched_cells
+ * @param {number} false_alarm_probability
+ * @param {number} noise_level
+ * @returns {number}
+ */
+function cfarCaThreshold(searched_cells, false_alarm_probability, noise_level) {
+    const ret = wasm.cfarCaThreshold(searched_cells, false_alarm_probability, noise_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaThreshold = cfarCaThreshold;
+
+/**
+ * Compute the closed-form Chan-Ho seed used by [`locateSource`].
+ *
+ * `mode` is `"toa"`, `"tdoa"`, or `{ mode: "tdoa", referenceSensor }`.
+ * Per-sensor speed overrides are not used by the closed-form equations, but
+ * they are used by [`locateSource`] during iterative refinement.
+ * @param {any} sensors
+ * @param {any} arrival_times_s
+ * @param {number} propagation_speed_m_s
+ * @param {any} mode
+ * @returns {any}
+ */
+function chanHoInitialGuess(sensors, arrival_times_s, propagation_speed_m_s, mode) {
+    const ret = wasm.chanHoInitialGuess(sensors, arrival_times_s, propagation_speed_m_s, mode);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.chanHoInitialGuess = chanHoInitialGuess;
+
 /**
  * Returns `true` when a diff has any findings.
  * @param {any} diff
@@ -17330,6 +17950,41 @@ function estimateDecayWithSpaceWeather(drag, table, request) {
 }
 exports.estimateDecayWithSpaceWeather = estimateDecayWithSpaceWeather;
 
+/**
+ * Exponentially weighted moving-average update.
+ *
+ * `alpha` must be in `[0, 1]`; the returned value is
+ * `previous + alpha * (sample - previous)`.
+ * @param {number} previous
+ * @param {number} sample
+ * @param {number} alpha
+ * @returns {number}
+ */
+function ewmaUpdate(previous, sample, alpha) {
+    const ret = wasm.ewmaUpdate(previous, sample, alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.ewmaUpdate = ewmaUpdate;
+
+/**
+ * EWMA update with `alpha = 1 / 2^shift`.
+ * @param {number} previous
+ * @param {number} sample
+ * @param {number} shift
+ * @returns {number}
+ */
+function ewmaUpdatePowerOfTwo(previous, sample, shift) {
+    const ret = wasm.ewmaUpdatePowerOfTwo(previous, sample, shift);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.ewmaUpdatePowerOfTwo = ewmaUpdatePowerOfTwo;
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -18512,6 +19167,26 @@ function jarqueBera(x) {
 }
 exports.jarqueBera = jarqueBera;
 
+/**
+ * Steady-state gains for a scalar constant-velocity Kalman filter.
+ *
+ * `trackingIndex`, `dt`, and `measurementVariance` must be positive. Returns
+ * `{ positionGain, rateGain }`; `rateGain * dt` equals the alpha-beta `beta`
+ * gain for the same tracking index.
+ * @param {number} tracking_index
+ * @param {number} dt
+ * @param {number} measurement_variance
+ * @returns {any}
+ */
+function kalmanCvSteadyStateGains(tracking_index, dt, measurement_variance) {
+    const ret = wasm.kalmanCvSteadyStateGains(tracking_index, dt, measurement_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.kalmanCvSteadyStateGains = kalmanCvSteadyStateGains;
+
 /**
  * GPS broadcast Klobuchar ionospheric group delay in the model's native units
  * (positive metres).
@@ -19082,6 +19757,30 @@ function loadSp3(bytes) {
 }
 exports.loadSp3 = loadSp3;
 
+/**
+ * Locate a source from sensor arrival times.
+ *
+ * `sensors` is an array of `{ positionM, propagationSpeedMS? }`; each
+ * `positionM` is a 2D or 3D Cartesian metre vector and all sensors must share
+ * the same dimension. `arrivalTimesS` is an aligned seconds array,
+ * `propagationSpeedMS` is the call-level speed in metres per second, and
+ * `options` may include `mode`, `referenceSensor`, `timingSigmaS`, `loss`,
+ * `fScaleS`, `ftol`, `xtol`, `gtol`, and `maxNfev`.
+ * @param {any} sensors
+ * @param {any} arrival_times_s
+ * @param {number} propagation_speed_m_s
+ * @param {any} options
+ * @returns {any}
+ */
+function locateSource(sensors, arrival_times_s, propagation_speed_m_s, options) {
+    const ret = wasm.locateSource(sensors, arrival_times_s, propagation_speed_m_s, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.locateSource = locateSource;
+
 /**
  * @param {bigint} start_unix_us
  * @param {bigint} end_unix_us
@@ -19136,6 +19835,35 @@ function lvlhRotation(position_km, velocity_km_s) {
 }
 exports.lvlhRotation = lvlhRotation;
 
+/**
+ * Gaussian consistency factor applied by [`madSpread`].
+ * @returns {number}
+ */
+function madGaussianConsistency() {
+    const ret = wasm.madGaussianConsistency();
+    return ret;
+}
+exports.madGaussianConsistency = madGaussianConsistency;
+
+/**
+ * Median absolute deviation spread estimate.
+ *
+ * `values` is a JS number array. The returned spread is
+ * `MAD_GAUSSIAN_CONSISTENCY * median(abs(value - median(values)))`, floored by
+ * `scaleFloor`.
+ * @param {any} values
+ * @param {number} scale_floor
+ * @returns {number}
+ */
+function madSpread(values, scale_floor) {
+    const ret = wasm.madSpread(values, scale_floor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.madSpread = madSpread;
+
 /**
  * @param {number} radius_km
  * @returns {number}
@@ -19568,6 +20296,69 @@ function nequickGStecTecu(_eval) {
 }
 exports.nequickGStecTecu = nequickGStecTecu;
 
+/**
+ * Scalar normalized innovation squared statistic.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @returns {number}
+ */
+function nis(innovation, innovation_variance) {
+    const ret = wasm.nis(innovation, innovation_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nis = nis;
+
+/**
+ * Bar-Shalom expected NIS value for `dof` measurement degrees of freedom.
+ * @param {number} dof
+ * @returns {number}
+ */
+function nisExpectedValue(dof) {
+    const ret = wasm.nisExpectedValue(dof);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nisExpectedValue = nisExpectedValue;
+
+/**
+ * Test a scalar innovation against a chi-square NIS gate.
+ *
+ * Returns `{ nis, threshold, inGate, dof }`, with `confidence` in `(0, 1)`.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @param {number} dof
+ * @param {number} confidence
+ * @returns {any}
+ */
+function nisGate(innovation, innovation_variance, dof, confidence) {
+    const ret = wasm.nisGate(innovation, innovation_variance, dof, confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.nisGate = nisGate;
+
+/**
+ * Chi-square NIS gate threshold for `dof` and confidence probability.
+ * @param {number} dof
+ * @param {number} confidence
+ * @returns {number}
+ */
+function nisGateThreshold(dof, confidence) {
+    const ret = wasm.nisGateThreshold(dof, confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nisGateThreshold = nisGateThreshold;
+
 /**
  * Parse bytes and return grouped epoch snapshots directly.
  * @param {Uint8Array} bytes
@@ -19655,6 +20446,21 @@ function normalCovariance(jacobian, m, n, variance_scale) {
 }
 exports.normalCovariance = normalCovariance;
 
+/**
+ * Scalar normalized innovation `innovation / sqrt(innovationVariance)`.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @returns {number}
+ */
+function normalizedInnovation(innovation, innovation_variance) {
+    const ret = wasm.normalizedInnovation(innovation, innovation_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.normalizedInnovation = normalizedInnovation;
+
 /**
  * Build the NTRIP connection request bytes for a config object.
  * @param {any} config
@@ -19671,6 +20477,43 @@ 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.
+ *
+ * The returned JS value is `[NaN, NaN, NaN]`, matching
+ * `sidereon_core::ephemeris::OBSERVABLE_STATE_MISSING_POSITION_ECEF_M`. Always
+ * check `elementResults[i].ok` or `statuses[i]` before using
+ * `positionsEcefM[i]`.
+ * @returns {any}
+ */
+function observableStateMissingPositionEcefM() {
+    const ret = wasm.observableStateMissingPositionEcefM();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observableStateMissingPositionEcefM = observableStateMissingPositionEcefM;
+
 /**
  * Predict observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -21892,6 +22735,78 @@ function solveWithFallback(precise, broadcast, request, policy) {
 }
 exports.solveWithFallback = solveWithFallback;
 
+/**
+ * Compute the timing Cramer-Rao lower bound for a proposed source position.
+ *
+ * The covariance is `(H^T H)^-1 * timingSigmaS^2`; position blocks are square
+ * metres and origin-time variance is square seconds.
+ * @param {any} sensors
+ * @param {any} source_position_m
+ * @param {number} propagation_speed_m_s
+ * @param {number} timing_sigma_s
+ * @returns {any}
+ */
+function sourceCrlb(sensors, source_position_m, propagation_speed_m_s, timing_sigma_s) {
+    const ret = wasm.sourceCrlb(sensors, source_position_m, propagation_speed_m_s, timing_sigma_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceCrlb = sourceCrlb;
+
+/**
+ * Compute timing DOP for a proposed source position.
+ *
+ * `sourcePositionM` is a 2D or 3D Cartesian metre vector in the same frame as
+ * the sensors. The returned DOP values multiply timing sigma in seconds to
+ * produce metres in the caller's Cartesian axes.
+ * @param {any} sensors
+ * @param {any} source_position_m
+ * @param {number} propagation_speed_m_s
+ * @returns {any}
+ */
+function sourceDop(sensors, source_position_m, propagation_speed_m_s) {
+    const ret = wasm.sourceDop(sensors, source_position_m, propagation_speed_m_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceDop = sourceDop;
+
+/**
+ * Return the plain mode object for TDOA solves against `referenceSensor`.
+ * @param {number} reference_sensor
+ * @returns {any}
+ */
+function sourceSolveModeTdoa(reference_sensor) {
+    const ret = wasm.sourceSolveModeTdoa(reference_sensor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceSolveModeTdoa = sourceSolveModeTdoa;
+
+/**
+ * Return the plain mode value for absolute time-of-arrival solves.
+ * @returns {string}
+ */
+function sourceSolveModeToa() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.sourceSolveModeToa();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.sourceSolveModeToa = sourceSolveModeToa;
+
 /**
  * Extract a parsed SP3 product as the canonical precise-ephemeris samples, one
  * per real position record in ascending epoch order.
@@ -23176,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));
@@ -23362,6 +24280,9 @@ const PppFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined
 const PppFloatSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pppfloatsolution_free(ptr, 1));
+const PreciseEphemerisInterpolantFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerisinterpolant_free(ptr, 1));
 const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));