@neilberkman/sidereon 0.17.0 → 0.18.0

package/pkg/sidereon.js

@@ -3507,6 +3507,21 @@ export class DgnssSolution {
 }
 if (Symbol.dispose) DgnssSolution.prototype[Symbol.dispose] = DgnssSolution.prototype.free;
 
+/**
+ * Early-late DLL processing mode for thermal-noise jitter.
+ * @enum {0 | 1}
+ */
+export 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",
+});
+
 /**
  * GNSS dilution-of-precision scalars.
  */
@@ -5645,6 +5660,229 @@ export class GlonassRecordJs {
 }
 if (Symbol.dispose) GlonassRecordJs.prototype[Symbol.dispose] = GlonassRecordJs.prototype.free;
 
+/**
+ * Stateful GNSS/INS filter resource.
+ */
+export 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;
+
 /**
  * One sampled rise/set/peak visibility pass, from `gnssPasses`.
  */
@@ -14649,6 +14887,239 @@ export class SbasSisError {
 }
 if (Symbol.dispose) SbasSisError.prototype[Symbol.dispose] = SbasSisError.prototype.free;
 
+/**
+ * Stable GNSS signal modulation used by the analysis functions.
+ */
+export class SignalAnalysisModulation {
+    static __wrap(ptr) {
+        const obj = Object.create(SignalAnalysisModulation.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalAnalysisModulationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalAnalysisModulationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signalanalysismodulation_free(ptr, 0);
+    }
+    /**
+     * Normalized in-band autocorrelation at a delay.
+     * @param {number} delay_s
+     * @param {number} receiver_bandwidth_hz
+     * @returns {number}
+     */
+    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 ret[0];
+    }
+    /**
+     * Build a BPSK(n) modulation, where the code rate is `n * 1.023 MHz`.
+     * @param {number} order
+     * @returns {SignalAnalysisModulation}
+     */
+    static bpsk(order) {
+        const ret = wasm.signalanalysismodulation_bpsk(order);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalAnalysisModulation.__wrap(ret[0]);
+    }
+    /**
+     * Build Galileo E1 CBOC(6,1,1/11) with the minus chip-pulse convention.
+     * @returns {SignalAnalysisModulation}
+     */
+    static cboc611Over11Minus() {
+        const ret = wasm.signalanalysismodulation_cboc611Over11Minus();
+        return SignalAnalysisModulation.__wrap(ret);
+    }
+    /**
+     * Build Galileo E1 CBOC(6,1,1/11) with the plus chip-pulse convention.
+     * @returns {SignalAnalysisModulation}
+     */
+    static cboc611Over11Plus() {
+        const ret = wasm.signalanalysismodulation_cboc611Over11Plus();
+        return SignalAnalysisModulation.__wrap(ret);
+    }
+    /**
+     * Code rate in hertz when the modulation has one unambiguous rate.
+     * @returns {number}
+     */
+    get codeRateHz() {
+        const ret = wasm.signalanalysismodulation_codeRateHz(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Build a cosine-phased BOC(m,n) modulation.
+     * @param {number} m
+     * @param {number} n
+     * @returns {SignalAnalysisModulation}
+     */
+    static cosineBoc(m, n) {
+        const ret = wasm.signalanalysismodulation_cosineBoc(m, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalAnalysisModulation.__wrap(ret[0]);
+    }
+    /**
+     * Published lower bound for DLL code-delay jitter.
+     * @param {any} options
+     * @returns {any}
+     */
+    dllLowerBound(options) {
+        const ret = wasm.signalanalysismodulation_dllLowerBound(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 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;
+
 /**
  * Per-constellation single-frequency pseudorange code-selection policy. Build
  * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
@@ -19936,6 +20407,23 @@ export function defaultPair(system) {
     return ret === 0 ? undefined : CarrierPair.__wrap(ret);
 }
 
+/**
+ * Default scenario seed as a hexadecimal string.
+ * @returns {string}
+ */
+export 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);
+    }
+}
+
 /**
  * Single-frequency carrier used by the SPP ionosphere-scaling policy.
  * @param {GnssSystem} system
@@ -20250,6 +20738,25 @@ export function eclipseStatus(satellite_position_km, sun_position_km) {
     return v3;
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
  * orthometric height and a geodetic position in radians, using the embedded
@@ -21252,6 +21759,23 @@ export function fspl(distance_km, frequency_mhz) {
     return ret[0];
 }
 
+/**
+ * Decode and re-encode fusion-state bytes through the core codec.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+export 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;
+}
+
 /**
  * Galileo NeQuick-G single-frequency ionospheric group delay (positive metres).
  *
@@ -25157,6 +25681,32 @@ export function sbasProtectionLevels(geometry, model, k) {
     return SbasProtection.__wrap(ret[0]);
 }
 
+/**
+ * Core scenario engine version string used in deterministic outputs.
+ * @returns {string}
+ */
+export 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);
+    }
+}
+
+/**
+ * Core scenario schema version accepted by the binding.
+ * @returns {number}
+ */
+export function scenarioSchemaVersion() {
+    const ret = wasm.scenarioSchemaVersion();
+    return ret >>> 0;
+}
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -25428,6 +25978,66 @@ export function sigmas(entries, options) {
     return SatelliteVector.__wrap(ret[0]);
 }
 
+/**
+ * Simulate a scenario from a JS object or JSON string and return JS arrays.
+ * @param {any} value
+ * @returns {any}
+ */
+export function simulateScenario(value) {
+    const ret = wasm.simulateScenario(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Simulate a scenario from a JS object or JSON string and return deterministic JSON bytes.
+ * @param {any} value
+ * @returns {Uint8Array}
+ */
+export 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;
+}
+
+/**
+ * Simulate a scenario from JSON text and return JS arrays.
+ * @param {string} text
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * Simulate a scenario from JSON text and return deterministic JSON bytes.
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export 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;
+}
+
 /**
  * Sample skewness of a residual set.
  *
@@ -25982,6 +26592,40 @@ export function sp3PreciseEphemerisSamples(sp3) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Spectral separation coefficient between two modulations, in dB-Hz.
+ * @param {SignalAnalysisModulation} desired
+ * @param {SignalAnalysisModulation} interference
+ * @param {number} receiver_bandwidth_hz
+ * @returns {number}
+ */
+export 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];
+}
+
+/**
+ * Spectral separation coefficient between two modulations, in hertz.
+ * @param {SignalAnalysisModulation} desired
+ * @param {SignalAnalysisModulation} interference
+ * @param {number} receiver_bandwidth_hz
+ * @returns {number}
+ */
+export 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];
+}
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -27331,6 +27975,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));
@@ -27604,6 +28251,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));