@neilberkman/sidereon 0.17.0 → 0.19.0

package/pkg-node/sidereon.js

@@ -3545,6 +3545,22 @@ class DgnssSolution {
 if (Symbol.dispose) DgnssSolution.prototype[Symbol.dispose] = DgnssSolution.prototype.free;
 exports.DgnssSolution = DgnssSolution;
 
+/**
+ * Early-late DLL processing mode for thermal-noise jitter.
+ * @enum {0 | 1}
+ */
+const DllProcessing = Object.freeze({
+    /**
+     * Coherent early-minus-late processing.
+     */
+    Coherent: 0, "0": "Coherent",
+    /**
+     * Non-coherent early-minus-late power processing with squaring loss.
+     */
+    NonCoherent: 1, "1": "NonCoherent",
+});
+exports.DllProcessing = DllProcessing;
+
 /**
  * GNSS dilution-of-precision scalars.
  */
@@ -5713,6 +5729,230 @@ class GlonassRecordJs {
 if (Symbol.dispose) GlonassRecordJs.prototype[Symbol.dispose] = GlonassRecordJs.prototype.free;
 exports.GlonassRecordJs = GlonassRecordJs;
 
+/**
+ * Stateful GNSS/INS filter resource.
+ */
+class GnssInsFilter {
+    static __wrap(ptr) {
+        const obj = Object.create(GnssInsFilter.prototype);
+        obj.__wbg_ptr = ptr;
+        GnssInsFilterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GnssInsFilterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gnssinsfilter_free(ptr, 0);
+    }
+    /**
+     * Replace retained-history capacities for later time-sync replay.
+     * @param {any} config
+     */
+    configureTimeSync(config) {
+        const ret = wasm.gnssinsfilter_configureTimeSync(this.__wbg_ptr, config);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Encode the current fusion state with the core versioned binary codec.
+     * @returns {Uint8Array}
+     */
+    encodeState() {
+        const ret = wasm.gnssinsfilter_encodeState(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Build a filter, then restore its state from versioned fusion-state bytes.
+     * @param {any} config
+     * @param {Uint8Array} bytes
+     * @returns {GnssInsFilter}
+     */
+    static fromStateBytes(config, bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.gnssinsfilter_fromStateBytes(config, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GnssInsFilter.__wrap(ret[0]);
+    }
+    /**
+     * Build a filter from a JS configuration object.
+     * @param {any} config
+     */
+    constructor(config) {
+        const ret = wasm.gnssinsfilter_new(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        GnssInsFilterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Propagate the filter with one IMU rate or increment sample.
+     * @param {any} sample
+     * @returns {any}
+     */
+    propagate(sample) {
+        const ret = wasm.gnssinsfilter_propagate(this.__wbg_ptr, sample);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Propagate the filter with a JS array of IMU samples.
+     * @param {any} samples
+     * @returns {any}
+     */
+    propagateBatch(samples) {
+        const ret = wasm.gnssinsfilter_propagateBatch(this.__wbg_ptr, samples);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Restore this filter from versioned fusion-state bytes.
+     * @param {Uint8Array} bytes
+     */
+    restoreState(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.gnssinsfilter_restoreState(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Current INS state, covariance, and last body-rate diagnostic.
+     * @returns {any}
+     */
+    state() {
+        const ret = wasm.gnssinsfilter_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Current tight-coupling receiver-clock state.
+     * @returns {any}
+     */
+    tightClockState() {
+        const ret = wasm.gnssinsfilter_tightClockState(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Current retained-history capacity and occupancy.
+     * @returns {any}
+     */
+    timeSyncStatus() {
+        const ret = wasm.gnssinsfilter_timeSyncStatus(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a loose position or position-velocity GNSS fix at the current epoch.
+     * @param {any} measurement
+     * @returns {any}
+     */
+    updateLoose(measurement) {
+        const ret = wasm.gnssinsfilter_updateLoose(this.__wbg_ptr, measurement);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
+     * @param {any} measurement
+     * @returns {any}
+     */
+    updateLooseTimeSync(measurement) {
+        const ret = wasm.gnssinsfilter_updateLooseTimeSync(this.__wbg_ptr, measurement);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a tight raw-observation epoch against a broadcast ephemeris source.
+     * @param {BroadcastEphemeris} broadcast
+     * @param {any} epoch
+     * @returns {any}
+     */
+    updateTightBroadcast(broadcast, epoch) {
+        _assertClass(broadcast, BroadcastEphemeris);
+        const ret = wasm.gnssinsfilter_updateTightBroadcast(this.__wbg_ptr, broadcast.__wbg_ptr, epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a tight broadcast update, replaying retained IMU checkpoints when it is late.
+     * @param {BroadcastEphemeris} broadcast
+     * @param {any} epoch
+     * @returns {any}
+     */
+    updateTightBroadcastTimeSync(broadcast, epoch) {
+        _assertClass(broadcast, BroadcastEphemeris);
+        const ret = wasm.gnssinsfilter_updateTightBroadcastTimeSync(this.__wbg_ptr, broadcast.__wbg_ptr, epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a tight raw-observation epoch against an SP3 source.
+     * @param {Sp3} sp3
+     * @param {any} epoch
+     * @returns {any}
+     */
+    updateTightSp3(sp3, epoch) {
+        _assertClass(sp3, Sp3);
+        const ret = wasm.gnssinsfilter_updateTightSp3(this.__wbg_ptr, sp3.__wbg_ptr, epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a tight SP3 update, replaying retained IMU checkpoints when it is late.
+     * @param {Sp3} sp3
+     * @param {any} epoch
+     * @returns {any}
+     */
+    updateTightSp3TimeSync(sp3, epoch) {
+        _assertClass(sp3, Sp3);
+        const ret = wasm.gnssinsfilter_updateTightSp3TimeSync(this.__wbg_ptr, sp3.__wbg_ptr, epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) GnssInsFilter.prototype[Symbol.dispose] = GnssInsFilter.prototype.free;
+exports.GnssInsFilter = GnssInsFilter;
+
 /**
  * One sampled rise/set/peak visibility pass, from `gnssPasses`.
  */
@@ -14820,111 +15060,345 @@ if (Symbol.dispose) SbasSisError.prototype[Symbol.dispose] = SbasSisError.protot
 exports.SbasSisError = SbasSisError;
 
 /**
- * Per-constellation single-frequency pseudorange code-selection policy. Build
- * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
- * the static `defaultFor(version)`.
+ * Stable GNSS signal modulation used by the analysis functions.
  */
-class SignalPolicy {
+class SignalAnalysisModulation {
     static __wrap(ptr) {
-        const obj = Object.create(SignalPolicy.prototype);
+        const obj = Object.create(SignalAnalysisModulation.prototype);
         obj.__wbg_ptr = ptr;
-        SignalPolicyFinalization.register(obj, obj.__wbg_ptr, obj);
+        SignalAnalysisModulationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SignalPolicyFinalization.unregister(this);
+        SignalAnalysisModulationFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signalpolicy_free(ptr, 0);
+        wasm.__wbg_signalanalysismodulation_free(ptr, 0);
     }
     /**
-     * The core default pseudorange policy for a RINEX version.
-     * @param {number} version
-     * @returns {SignalPolicy}
+     * Normalized in-band autocorrelation at a delay.
+     * @param {number} delay_s
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
      */
-    static defaultFor(version) {
-        const ret = wasm.signalpolicy_defaultFor(version);
+    autocorrelation(delay_s, receiver_bandwidth_hz) {
+        const ret = wasm.signalanalysismodulation_autocorrelation(this.__wbg_ptr, delay_s, receiver_bandwidth_hz);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return SignalPolicy.__wrap(ret[0]);
+        return ret[0];
     }
     /**
-     * An empty policy with no constellation preferences.
+     * Build a BPSK(n) modulation, where the code rate is `n * 1.023 MHz`.
+     * @param {number} order
+     * @returns {SignalAnalysisModulation}
      */
-    constructor() {
-        const ret = wasm.signalpolicy_new();
-        this.__wbg_ptr = ret;
-        SignalPolicyFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static bpsk(order) {
+        const ret = wasm.signalanalysismodulation_bpsk(order);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalAnalysisModulation.__wrap(ret[0]);
     }
     /**
-     * Return a copy with one constellation's preference list set.
-     * @param {GnssSystem} system
-     * @param {string[]} codes
-     * @returns {SignalPolicy}
+     * Build Galileo E1 CBOC(6,1,1/11) with the minus chip-pulse convention.
+     * @returns {SignalAnalysisModulation}
      */
-    withSystem(system, codes) {
-        const ptr0 = passArrayJsValueToWasm0(codes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signalpolicy_withSystem(this.__wbg_ptr, system, ptr0, len0);
-        return SignalPolicy.__wrap(ret);
+    static cboc611Over11Minus() {
+        const ret = wasm.signalanalysismodulation_cboc611Over11Minus();
+        return SignalAnalysisModulation.__wrap(ret);
     }
-}
-if (Symbol.dispose) SignalPolicy.prototype[Symbol.dispose] = SignalPolicy.prototype.free;
-exports.SignalPolicy = SignalPolicy;
-
-/**
- * Reason a carrier-phase arc split was flagged.
- * @enum {0 | 1 | 2 | 3}
- */
-const SlipReason = Object.freeze({
     /**
-     * Loss-of-lock indicator bit 0 set on either band.
+     * Build Galileo E1 CBOC(6,1,1/11) with the plus chip-pulse convention.
+     * @returns {SignalAnalysisModulation}
      */
-    Lli: 0, "0": "Lli",
+    static cboc611Over11Plus() {
+        const ret = wasm.signalanalysismodulation_cboc611Over11Plus();
+        return SignalAnalysisModulation.__wrap(ret);
+    }
     /**
-     * Gap to the previous usable sample exceeded the threshold.
+     * Code rate in hertz when the modulation has one unambiguous rate.
+     * @returns {number}
      */
-    DataGap: 1, "1": "DataGap",
+    get codeRateHz() {
+        const ret = wasm.signalanalysismodulation_codeRateHz(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
     /**
-     * Geometry-free phase step exceeded the threshold.
+     * Build a cosine-phased BOC(m,n) modulation.
+     * @param {number} m
+     * @param {number} n
+     * @returns {SignalAnalysisModulation}
      */
-    GeometryFree: 2, "2": "GeometryFree",
+    static cosineBoc(m, n) {
+        const ret = wasm.signalanalysismodulation_cosineBoc(m, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalAnalysisModulation.__wrap(ret[0]);
+    }
     /**
-     * Melbourne-Wubbena step exceeded the threshold.
+     * Published lower bound for DLL code-delay jitter.
+     * @param {any} options
+     * @returns {any}
      */
-    MelbourneWubbena: 3, "3": "MelbourneWubbena",
-});
-exports.SlipReason = SlipReason;
-
-/**
- * Cycle-slip classification for one input epoch.
- */
-class SlipResult {
-    static __wrap(ptr) {
-        const obj = Object.create(SlipResult.prototype);
-        obj.__wbg_ptr = ptr;
-        SlipResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SlipResultFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_slipresult_free(ptr, 0);
+    dllLowerBound(options) {
+        const ret = wasm.signalanalysismodulation_dllLowerBound(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Current geometry-free phase, metres, or `undefined`.
-     * @returns {number | undefined}
+     * Early-late DLL thermal-noise jitter for this modulation.
+     * @param {any} options
+     * @param {DllProcessing} processing
+     * @returns {any}
+     */
+    dllThermalNoiseJitter(options, processing) {
+        const ret = wasm.signalanalysismodulation_dllThermalNoiseJitter(this.__wbg_ptr, options, processing);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Fraction of total signal power inside a two-sided receiver bandwidth.
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
+     */
+    fractionPowerInBand(receiver_bandwidth_hz) {
+        const ret = wasm.signalanalysismodulation_fractionPowerInBand(this.__wbg_ptr, receiver_bandwidth_hz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Stable core label for this modulation.
+     * @returns {string}
+     */
+    get label() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signalanalysismodulation_label(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);
+        }
+    }
+    /**
+     * Build the normalized MBOC(6,1,1/11) spectrum.
+     * @returns {SignalAnalysisModulation}
+     */
+    static mboc611Over11() {
+        const ret = wasm.signalanalysismodulation_mboc611Over11();
+        return SignalAnalysisModulation.__wrap(ret);
+    }
+    /**
+     * One-path early-late multipath error envelope on a delay grid.
+     * @param {any} options
+     * @param {Float64Array} delay_chips
+     * @returns {any}
+     */
+    multipathErrorEnvelope(options, delay_chips) {
+        const ptr0 = passArrayF64ToWasm0(delay_chips, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signalanalysismodulation_multipathErrorEnvelope(this.__wbg_ptr, options, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Signal power inside a two-sided receiver bandwidth.
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
+     */
+    powerInBand(receiver_bandwidth_hz) {
+        const ret = wasm.signalanalysismodulation_powerInBand(this.__wbg_ptr, receiver_bandwidth_hz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Normalized power spectral density at an offset frequency, in `1/Hz`.
+     * @param {number} offset_hz
+     * @returns {number}
+     */
+    psdHz(offset_hz) {
+        const ret = wasm.signalanalysismodulation_psdHz(this.__wbg_ptr, offset_hz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * RMS, or Gabor, bandwidth over a two-sided receiver bandwidth.
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
+     */
+    rmsBandwidthHz(receiver_bandwidth_hz) {
+        const ret = wasm.signalanalysismodulation_rmsBandwidthHz(this.__wbg_ptr, receiver_bandwidth_hz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Build a sine-phased BOC(m,n) modulation.
+     * @param {number} m
+     * @param {number} n
+     * @returns {SignalAnalysisModulation}
+     */
+    static sineBoc(m, n) {
+        const ret = wasm.signalanalysismodulation_sineBoc(m, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalAnalysisModulation.__wrap(ret[0]);
+    }
+    /**
+     * Build the GPS L1C pilot TMBOC(6,1,4/33) spectrum.
+     * @returns {SignalAnalysisModulation}
+     */
+    static tmboc614Over33() {
+        const ret = wasm.signalanalysismodulation_tmboc614Over33();
+        return SignalAnalysisModulation.__wrap(ret);
+    }
+    /**
+     * SSC against white interference normalized over the receiver bandwidth.
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
+     */
+    whiteNoiseSpectralSeparationHz(receiver_bandwidth_hz) {
+        const ret = wasm.signalanalysismodulation_whiteNoiseSpectralSeparationHz(this.__wbg_ptr, receiver_bandwidth_hz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) SignalAnalysisModulation.prototype[Symbol.dispose] = SignalAnalysisModulation.prototype.free;
+exports.SignalAnalysisModulation = SignalAnalysisModulation;
+
+/**
+ * Per-constellation single-frequency pseudorange code-selection policy. Build
+ * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
+ * the static `defaultFor(version)`.
+ */
+class SignalPolicy {
+    static __wrap(ptr) {
+        const obj = Object.create(SignalPolicy.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalPolicyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalPolicyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signalpolicy_free(ptr, 0);
+    }
+    /**
+     * The core default pseudorange policy for a RINEX version.
+     * @param {number} version
+     * @returns {SignalPolicy}
+     */
+    static defaultFor(version) {
+        const ret = wasm.signalpolicy_defaultFor(version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalPolicy.__wrap(ret[0]);
+    }
+    /**
+     * An empty policy with no constellation preferences.
+     */
+    constructor() {
+        const ret = wasm.signalpolicy_new();
+        this.__wbg_ptr = ret;
+        SignalPolicyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return a copy with one constellation's preference list set.
+     * @param {GnssSystem} system
+     * @param {string[]} codes
+     * @returns {SignalPolicy}
+     */
+    withSystem(system, codes) {
+        const ptr0 = passArrayJsValueToWasm0(codes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signalpolicy_withSystem(this.__wbg_ptr, system, ptr0, len0);
+        return SignalPolicy.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SignalPolicy.prototype[Symbol.dispose] = SignalPolicy.prototype.free;
+exports.SignalPolicy = SignalPolicy;
+
+/**
+ * Reason a carrier-phase arc split was flagged.
+ * @enum {0 | 1 | 2 | 3}
+ */
+const SlipReason = Object.freeze({
+    /**
+     * Loss-of-lock indicator bit 0 set on either band.
+     */
+    Lli: 0, "0": "Lli",
+    /**
+     * Gap to the previous usable sample exceeded the threshold.
+     */
+    DataGap: 1, "1": "DataGap",
+    /**
+     * Geometry-free phase step exceeded the threshold.
+     */
+    GeometryFree: 2, "2": "GeometryFree",
+    /**
+     * Melbourne-Wubbena step exceeded the threshold.
+     */
+    MelbourneWubbena: 3, "3": "MelbourneWubbena",
+});
+exports.SlipReason = SlipReason;
+
+/**
+ * Cycle-slip classification for one input epoch.
+ */
+class SlipResult {
+    static __wrap(ptr) {
+        const obj = Object.create(SlipResult.prototype);
+        obj.__wbg_ptr = ptr;
+        SlipResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SlipResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_slipresult_free(ptr, 0);
+    }
+    /**
+     * Current geometry-free phase, metres, or `undefined`.
+     * @returns {number | undefined}
      */
     get gfM() {
         const ret = wasm.slipresult_gfM(this.__wbg_ptr);
@@ -15016,6 +15490,44 @@ class SmoothCodeResult {
 if (Symbol.dispose) SmoothCodeResult.prototype[Symbol.dispose] = SmoothCodeResult.prototype.free;
 exports.SmoothCodeResult = SmoothCodeResult;
 
+class SmoothedTrack {
+    static __wrap(ptr) {
+        const obj = Object.create(SmoothedTrack.prototype);
+        obj.__wbg_ptr = ptr;
+        SmoothedTrackFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SmoothedTrackFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_smoothedtrack_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.smoothedtrack_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.smoothedtrack_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) SmoothedTrack.prototype[Symbol.dispose] = SmoothedTrack.prototype.free;
+exports.SmoothedTrack = SmoothedTrack;
+
 /**
  * A receiver solution paired with the provenance of the ephemeris that produced
  * it. Returned by [`solveWithFallback`].
@@ -18625,39 +19137,362 @@ exports.Tle = Tle;
  */
 class TleFit {
     static __wrap(ptr) {
-        const obj = Object.create(TleFit.prototype);
+        const obj = Object.create(TleFit.prototype);
+        obj.__wbg_ptr = ptr;
+        TleFitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TleFitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tlefit_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get elements() {
+        const ret = wasm.tlefit_elements(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get line1() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tlefit_line1(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get line2() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tlefit_line2(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);
+        }
+    }
+    /**
+     * @returns {Omm}
+     */
+    get omm() {
+        const ret = wasm.tlefit_omm(this.__wbg_ptr);
+        return Omm.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    get stats() {
+        const ret = wasm.tlefit_stats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string[]}
+     */
+    toLines() {
+        const ret = wasm.tlefit_toLines(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TleFit.prototype[Symbol.dispose] = TleFit.prototype.free;
+exports.TleFit = TleFit;
+
+/**
+ * TEME states from a batched SGP4 propagation. Each array is flat row-major,
+ * length `3 * epochCount`.
+ */
+class TlePropagation {
+    static __wrap(ptr) {
+        const obj = Object.create(TlePropagation.prototype);
+        obj.__wbg_ptr = ptr;
+        TlePropagationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TlePropagationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tlepropagation_free(ptr, 0);
+    }
+    /**
+     * Number of epochs propagated.
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.tlepropagation_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * TEME positions, km, flat `[x0, y0, z0, x1, ...]`.
+     * @returns {Float64Array}
+     */
+    get positionKm() {
+        const ret = wasm.tlepropagation_positionKm(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * TEME velocities, km/s, flat `[vx0, vy0, vz0, ...]`.
+     * @returns {Float64Array}
+     */
+    get velocityKmS() {
+        const ret = wasm.tlepropagation_velocityKmS(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) TlePropagation.prototype[Symbol.dispose] = TlePropagation.prototype.free;
+exports.TlePropagation = TlePropagation;
+
+class TrackFilter {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackFilter.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackFilterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackFilterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackfilter_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get accelerationVarianceSpectralDensityM2S3() {
+        const ret = wasm.trackfilter_accelerationVarianceSpectralDensityM2S3(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get dimension() {
+        const ret = wasm.trackfilter_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Build a filter from a position fix and uncertain zero initial velocity.
+     * @param {any} config
+     * @returns {TrackFilter}
+     */
+    static fromPosition(config) {
+        const ret = wasm.trackfilter_fromPosition(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackFilter.__wrap(ret[0]);
+    }
+    /**
+     * Build a stateful no-IMU track filter from a `TrackFilterConfig`.
+     * @param {TrackFilterConfig} config
+     */
+    constructor(config) {
+        _assertClass(config, TrackFilterConfig);
+        const ret = wasm.trackfilter_new(config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        TrackFilterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    positionInnovation(request) {
+        const ret = wasm.trackfilter_positionInnovation(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} dt_s
+     * @returns {any}
+     */
+    predict(dt_s) {
+        const ret = wasm.trackfilter_predict(this.__wbg_ptr, dt_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} dt_s
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    predictRecorded(dt_s, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_predictRecorded(this.__wbg_ptr, dt_s, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {TrackRtsHistoryBuilder} history
+     */
+    recordPredictionOnly(history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_recordPredictionOnly(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    get state() {
+        const ret = wasm.trackfilter_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    stateInnovation(request) {
+        const ret = wasm.trackfilter_stateInnovation(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updatePosition(request) {
+        const ret = wasm.trackfilter_updatePosition(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updatePositionGated(request) {
+        const ret = wasm.trackfilter_updatePositionGated(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updatePositionGatedRecorded(request, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_updatePositionGatedRecorded(this.__wbg_ptr, request, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updatePositionRecorded(request, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_updatePositionRecorded(this.__wbg_ptr, request, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updateState(request) {
+        const ret = wasm.trackfilter_updateState(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) TrackFilter.prototype[Symbol.dispose] = TrackFilter.prototype.free;
+exports.TrackFilter = TrackFilter;
+
+class TrackFilterConfig {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackFilterConfig.prototype);
         obj.__wbg_ptr = ptr;
-        TleFitFinalization.register(obj, obj.__wbg_ptr, obj);
+        TrackFilterConfigFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TleFitFinalization.unregister(this);
+        TrackFilterConfigFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tlefit_free(ptr, 0);
+        wasm.__wbg_trackfilterconfig_free(ptr, 0);
     }
     /**
-     * @returns {any}
+     * @returns {number}
      */
-    get elements() {
-        const ret = wasm.tlefit_elements(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    get dimension() {
+        const ret = wasm.trackfilterconfig_dimension(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * @returns {string}
      */
-    get line1() {
+    get frame() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tlefit_line1(this.__wbg_ptr);
+            const ret = wasm.trackfilterconfig_frame(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -18666,102 +19501,141 @@ class TleFit {
         }
     }
     /**
-     * @returns {string}
+     * Build a config from a position fix and uncertain zero initial velocity.
+     * @param {any} config
+     * @returns {TrackFilterConfig}
      */
-    get line2() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.tlefit_line2(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);
+    static fromPosition(config) {
+        const ret = wasm.trackfilterconfig_fromPosition(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return TrackFilterConfig.__wrap(ret[0]);
     }
     /**
-     * @returns {Omm}
+     * @returns {number}
      */
-    get omm() {
-        const ret = wasm.tlefit_omm(this.__wbg_ptr);
-        return Omm.__wrap(ret);
+    get initialTS() {
+        const ret = wasm.trackfilterconfig_initialTS(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @returns {any}
+     * Build a no-IMU track filter config from a JS object.
+     * @param {any} config
      */
-    get stats() {
-        const ret = wasm.tlefit_stats(this.__wbg_ptr);
+    constructor(config) {
+        const ret = wasm.trackfilterconfig_new(config);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        this.__wbg_ptr = ret[0];
+        TrackFilterConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * @returns {string[]}
+     * @returns {any}
      */
-    toLines() {
-        const ret = wasm.tlefit_toLines(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    toObject() {
+        const ret = wasm.trackfilterconfig_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
-if (Symbol.dispose) TleFit.prototype[Symbol.dispose] = TleFit.prototype.free;
-exports.TleFit = TleFit;
+if (Symbol.dispose) TrackFilterConfig.prototype[Symbol.dispose] = TrackFilterConfig.prototype.free;
+exports.TrackFilterConfig = TrackFilterConfig;
 
-/**
- * TEME states from a batched SGP4 propagation. Each array is flat row-major,
- * length `3 * epochCount`.
- */
-class TlePropagation {
+class TrackRtsHistory {
     static __wrap(ptr) {
-        const obj = Object.create(TlePropagation.prototype);
+        const obj = Object.create(TrackRtsHistory.prototype);
         obj.__wbg_ptr = ptr;
-        TlePropagationFinalization.register(obj, obj.__wbg_ptr, obj);
+        TrackRtsHistoryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TlePropagationFinalization.unregister(this);
+        TrackRtsHistoryFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tlepropagation_free(ptr, 0);
+        wasm.__wbg_trackrtshistory_free(ptr, 0);
     }
     /**
-     * Number of epochs propagated.
      * @returns {number}
      */
     get epochCount() {
-        const ret = wasm.tlepropagation_epochCount(this.__wbg_ptr);
+        const ret = wasm.trackrtshistory_epochCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * TEME positions, km, flat `[x0, y0, z0, x1, ...]`.
-     * @returns {Float64Array}
+     * @returns {any}
      */
-    get positionKm() {
-        const ret = wasm.tlepropagation_positionKm(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    get epochs() {
+        const ret = wasm.trackrtshistory_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) TrackRtsHistory.prototype[Symbol.dispose] = TrackRtsHistory.prototype.free;
+exports.TrackRtsHistory = TrackRtsHistory;
+
+class TrackRtsHistoryBuilder {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackRtsHistoryBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackRtsHistoryBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackRtsHistoryBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackrtshistorybuilder_free(ptr, 0);
     }
     /**
-     * TEME velocities, km/s, flat `[vx0, vy0, vz0, ...]`.
-     * @returns {Float64Array}
+     * @returns {TrackRtsHistory}
      */
-    get velocityKmS() {
-        const ret = wasm.tlepropagation_velocityKmS(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    finish() {
+        const ret = wasm.trackrtshistorybuilder_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackRtsHistory.__wrap(ret[0]);
+    }
+    /**
+     * Start a history from the filter's current state.
+     * @param {TrackFilter} filter
+     * @returns {TrackRtsHistoryBuilder}
+     */
+    static fromFilter(filter) {
+        _assertClass(filter, TrackFilter);
+        const ret = wasm.trackrtshistorybuilder_fromFilter(filter.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackRtsHistoryBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Start an empty history for manual recording.
+     */
+    constructor() {
+        const ret = wasm.trackrtshistorybuilder_new();
+        this.__wbg_ptr = ret;
+        TrackRtsHistoryBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
-if (Symbol.dispose) TlePropagation.prototype[Symbol.dispose] = TlePropagation.prototype.free;
-exports.TlePropagation = TlePropagation;
+if (Symbol.dispose) TrackRtsHistoryBuilder.prototype[Symbol.dispose] = TrackRtsHistoryBuilder.prototype.free;
+exports.TrackRtsHistoryBuilder = TrackRtsHistoryBuilder;
 
 /**
  * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
@@ -20213,6 +21087,24 @@ function defaultPair(system) {
 }
 exports.defaultPair = defaultPair;
 
+/**
+ * Default scenario seed as a hexadecimal string.
+ * @returns {string}
+ */
+function defaultScenarioSeedHex() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.defaultScenarioSeedHex();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.defaultScenarioSeedHex = defaultScenarioSeedHex;
+
 /**
  * Single-frequency carrier used by the SPP ionosphere-scaling policy.
  * @param {GnssSystem} system
@@ -20543,6 +21435,26 @@ function eclipseStatus(satellite_position_km, sun_position_km) {
 }
 exports.eclipseStatus = eclipseStatus;
 
+/**
+ * Effective C/N0 degradation for one finite-band interference term.
+ * @param {SignalAnalysisModulation} desired
+ * @param {SignalAnalysisModulation} interference
+ * @param {number} cn0_db_hz
+ * @param {number} receiver_bandwidth_hz
+ * @param {number} power_ratio_to_carrier
+ * @returns {any}
+ */
+function effectiveCn0Degradation(desired, interference, cn0_db_hz, receiver_bandwidth_hz, power_ratio_to_carrier) {
+    _assertClass(desired, SignalAnalysisModulation);
+    _assertClass(interference, SignalAnalysisModulation);
+    const ret = wasm.effectiveCn0Degradation(desired.__wbg_ptr, interference.__wbg_ptr, cn0_db_hz, receiver_bandwidth_hz, power_ratio_to_carrier);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.effectiveCn0Degradation = effectiveCn0Degradation;
+
 /**
  * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
  * orthometric height and a geodetic position in radians, using the embedded
@@ -21594,6 +22506,24 @@ function fspl(distance_km, frequency_mhz) {
 }
 exports.fspl = fspl;
 
+/**
+ * Decode and re-encode fusion-state bytes through the core codec.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+function fusionStateBytesRoundTrip(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fusionStateBytesRoundTrip(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.fusionStateBytesRoundTrip = fusionStateBytesRoundTrip;
+
 /**
  * Galileo NeQuick-G single-frequency ionospheric group delay (positive metres).
  *
@@ -25711,6 +26641,34 @@ function sbasProtectionLevels(geometry, model, k) {
 }
 exports.sbasProtectionLevels = sbasProtectionLevels;
 
+/**
+ * Core scenario engine version string used in deterministic outputs.
+ * @returns {string}
+ */
+function scenarioEngineVersion() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.scenarioEngineVersion();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.scenarioEngineVersion = scenarioEngineVersion;
+
+/**
+ * Core scenario schema version accepted by the binding.
+ * @returns {number}
+ */
+function scenarioSchemaVersion() {
+    const ret = wasm.scenarioSchemaVersion();
+    return ret >>> 0;
+}
+exports.scenarioSchemaVersion = scenarioSchemaVersion;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -25995,6 +26953,70 @@ function sigmas(entries, options) {
 }
 exports.sigmas = sigmas;
 
+/**
+ * Simulate a scenario from a JS object or JSON string and return JS arrays.
+ * @param {any} value
+ * @returns {any}
+ */
+function simulateScenario(value) {
+    const ret = wasm.simulateScenario(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.simulateScenario = simulateScenario;
+
+/**
+ * Simulate a scenario from a JS object or JSON string and return deterministic JSON bytes.
+ * @param {any} value
+ * @returns {Uint8Array}
+ */
+function simulateScenarioBytes(value) {
+    const ret = wasm.simulateScenarioBytes(value);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+exports.simulateScenarioBytes = simulateScenarioBytes;
+
+/**
+ * Simulate a scenario from JSON text and return JS arrays.
+ * @param {string} text
+ * @returns {any}
+ */
+function simulateScenarioJson(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.simulateScenarioJson(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.simulateScenarioJson = simulateScenarioJson;
+
+/**
+ * Simulate a scenario from JSON text and return deterministic JSON bytes.
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function simulateScenarioJsonBytes(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.simulateScenarioJsonBytes(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.simulateScenarioJsonBytes = simulateScenarioJsonBytes;
+
 /**
  * Sample skewness of a residual set.
  *
@@ -26072,6 +27094,20 @@ function smoothIonoFreeCode(arc, options, hatch_window_cap) {
 }
 exports.smoothIonoFreeCode = smoothIonoFreeCode;
 
+/**
+ * @param {TrackRtsHistory} history
+ * @returns {SmoothedTrack}
+ */
+function smoothTrackRts(history) {
+    _assertClass(history, TrackRtsHistory);
+    const ret = wasm.smoothTrackRts(history.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SmoothedTrack.__wrap(ret[0]);
+}
+exports.smoothTrackRts = smoothTrackRts;
+
 /**
  * Post-correlation predetection SNR in decibels.
  * @param {number} cn0_dbhz
@@ -26576,6 +27612,42 @@ function sp3PreciseEphemerisSamples(sp3) {
 }
 exports.sp3PreciseEphemerisSamples = sp3PreciseEphemerisSamples;
 
+/**
+ * Spectral separation coefficient between two modulations, in dB-Hz.
+ * @param {SignalAnalysisModulation} desired
+ * @param {SignalAnalysisModulation} interference
+ * @param {number} receiver_bandwidth_hz
+ * @returns {number}
+ */
+function spectralSeparationCoefficientDbHz(desired, interference, receiver_bandwidth_hz) {
+    _assertClass(desired, SignalAnalysisModulation);
+    _assertClass(interference, SignalAnalysisModulation);
+    const ret = wasm.spectralSeparationCoefficientDbHz(desired.__wbg_ptr, interference.__wbg_ptr, receiver_bandwidth_hz);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.spectralSeparationCoefficientDbHz = spectralSeparationCoefficientDbHz;
+
+/**
+ * Spectral separation coefficient between two modulations, in hertz.
+ * @param {SignalAnalysisModulation} desired
+ * @param {SignalAnalysisModulation} interference
+ * @param {number} receiver_bandwidth_hz
+ * @returns {number}
+ */
+function spectralSeparationCoefficientHz(desired, interference, receiver_bandwidth_hz) {
+    _assertClass(desired, SignalAnalysisModulation);
+    _assertClass(interference, SignalAnalysisModulation);
+    const ret = wasm.spectralSeparationCoefficientHz(desired.__wbg_ptr, interference.__wbg_ptr, receiver_bandwidth_hz);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.spectralSeparationCoefficientHz = spectralSeparationCoefficientHz;
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -27964,6 +29036,9 @@ const GeometryQualityFinalization = (typeof FinalizationRegistry === 'undefined'
 const GlonassRecordJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_glonassrecordjs_free(ptr, 1));
+const GnssInsFilterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gnssinsfilter_free(ptr, 1));
 const GnssPassFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_gnsspass_free(ptr, 1));
@@ -28237,6 +29312,9 @@ const SbasProtectionFinalization = (typeof FinalizationRegistry === 'undefined')
 const SbasSisErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sbassiserror_free(ptr, 1));
+const SignalAnalysisModulationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signalanalysismodulation_free(ptr, 1));
 const SignalPolicyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalpolicy_free(ptr, 1));
@@ -28246,6 +29324,9 @@ const SlipResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const SmoothCodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smoothcoderesult_free(ptr, 1));
+const SmoothedTrackFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_smoothedtrack_free(ptr, 1));
 const SourcedSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sourcedsolution_free(ptr, 1));
@@ -28354,6 +29435,18 @@ const TleFitFinalization = (typeof FinalizationRegistry === 'undefined')
 const TlePropagationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tlepropagation_free(ptr, 1));
+const TrackFilterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackfilter_free(ptr, 1));
+const TrackFilterConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackfilterconfig_free(ptr, 1));
+const TrackRtsHistoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackrtshistory_free(ptr, 1));
+const TrackRtsHistoryBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackrtshistorybuilder_free(ptr, 1));
 const Ut1CoverageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ut1coverage_free(ptr, 1));