@neilberkman/sidereon 0.16.1 → 0.18.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.
  */
@@ -4328,6 +4344,153 @@ class EllipsoidalHeightM {
 if (Symbol.dispose) EllipsoidalHeightM.prototype[Symbol.dispose] = EllipsoidalHeightM.prototype.free;
 exports.EllipsoidalHeightM = EllipsoidalHeightM;
 
+/**
+ * Contiguous state and media-correction arrays from one emission batch.
+ */
+class EmissionMediaBatch {
+    static __wrap(ptr) {
+        const obj = Object.create(EmissionMediaBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        EmissionMediaBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EmissionMediaBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_emissionmediabatch_free(ptr, 0);
+    }
+    /**
+     * Satellite clock offsets in seconds, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get clockS() {
+        const ret = wasm.emissionmediabatch_clockS(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Number of satellite rows in the batch.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.emissionmediabatch_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Per-row success and error messages as `{ ok, error }[]`.
+     * @returns {any}
+     */
+    get elementResults() {
+        const ret = wasm.emissionmediabatch_elementResults(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Error message for row `index`, or `undefined` when the row has no error.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    error(index) {
+        const ret = wasm.emissionmediabatch_error(this.__wbg_ptr, index);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Ionospheric slant group delays in metres, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get ionosphereSlantDelayM() {
+        const ret = wasm.emissionmediabatch_ionosphereSlantDelayM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Satellite ECEF positions as flat `[x0, y0, z0, ...]`, metres.
+     *
+     * Rows without a usable position are filled with `NaN`; check `statuses`
+     * before consuming the corresponding row.
+     * @returns {Float64Array}
+     */
+    get positionEcefM() {
+        const ret = wasm.emissionmediabatch_positionEcefM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Per-row status labels, index-aligned with the numeric arrays.
+     * @returns {string[]}
+     */
+    get statusLabels() {
+        const ret = wasm.emissionmediabatch_statusLabels(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Per-row typed status values, index-aligned with the numeric arrays.
+     * @returns {any[]}
+     */
+    get statuses() {
+        const ret = wasm.emissionmediabatch_statuses(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Tropospheric slant delays in metres, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get troposphereDelayM() {
+        const ret = wasm.emissionmediabatch_troposphereDelayM(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) EmissionMediaBatch.prototype[Symbol.dispose] = EmissionMediaBatch.prototype.free;
+exports.EmissionMediaBatch = EmissionMediaBatch;
+
+/**
+ * Per-satellite status for an emission media batch row.
+ * @enum {0 | 1 | 2 | 3}
+ */
+const EmissionMediaStatus = Object.freeze({
+    /**
+     * State, clock, and requested media corrections were produced.
+     */
+    Valid: 0, "0": "Valid",
+    /**
+     * The ephemeris product has no usable state for this satellite and epoch.
+     */
+    Gap: 1, "1": "Gap",
+    /**
+     * A state was available, but elevation was below the requested cutoff.
+     */
+    BelowElevationCutoff: 2, "2": "BelowElevationCutoff",
+    /**
+     * A non-gap scalar evaluation error occurred.
+     */
+    Error: 3, "3": "Error",
+});
+exports.EmissionMediaStatus = EmissionMediaStatus;
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -4953,6 +5116,205 @@ const GeodesicError = Object.freeze({
 });
 exports.GeodesicError = GeodesicError;
 
+/**
+ * A geodesic polygon fence on WGS84.
+ */
+class Geofence {
+    static __wrap(ptr) {
+        const obj = Object.create(Geofence.prototype);
+        obj.__wbg_ptr = ptr;
+        GeofenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeofenceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_geofence_free(ptr, 0);
+    }
+    /**
+     * Containment probability for one position and uncertainty object.
+     *
+     * `uncertainty.kind` is one of `"enuCovarianceM2"`, `"ecefCovarianceM2"`,
+     * `"cepRadiusM"`, or `"horizontalRadius"`. `options.method` is
+     * `"boundaryNormal"` or `"planarQuadrature"`.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @param {any} uncertainty_value
+     * @param {any} options
+     * @returns {number}
+     */
+    containmentProbability(lat_rad, lon_rad, height_m, uncertainty_value, options) {
+        const ret = wasm.geofence_containmentProbability(this.__wbg_ptr, lat_rad, lon_rad, height_m, uncertainty_value, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Boolean containment for one WGS84 geodetic position.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {boolean}
+     */
+    contains(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_contains(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Probabilistic crossing detection over geodetic position estimates.
+     *
+     * `samples` is an array of `{ latRad, lonRad, heightM?, uncertainty }`.
+     * `options.enterConfidence` and `options.leaveConfidence` configure
+     * hysteresis; absent values use the core defaults.
+     * @param {any} samples
+     * @param {any} options
+     * @returns {any}
+     */
+    crossingProbability(samples, options) {
+        const ret = wasm.geofence_crossingProbability(this.__wbg_ptr, samples, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Signed distance to the fence boundary in metres.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {number}
+     */
+    distanceToBoundary(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_distanceToBoundary(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Number of polygon edges.
+     * @returns {number}
+     */
+    get edgeCount() {
+        const ret = wasm.geofence_edgeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+     *
+     * `vertices` is `[latRad, lonRad, ...]`. Use `geofenceFromVertices3d`
+     * for `[latRad, lonRad, heightM, ...]` rows.
+     * @param {Float64Array} vertices
+     */
+    constructor(vertices) {
+        const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geofence_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        GeofenceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Whether the core small-region planar path can evaluate this position.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {boolean}
+     */
+    planarFastPathApplies(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_planarFastPathApplies(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Fence vertices in open-polygon form as flat `[latRad, lonRad, heightM]` rows.
+     * @returns {Float64Array}
+     */
+    get vertices() {
+        const ret = wasm.geofence_vertices(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) Geofence.prototype[Symbol.dispose] = Geofence.prototype.free;
+exports.Geofence = Geofence;
+
+/**
+ * Geofence crossing event direction.
+ * @enum {0 | 1}
+ */
+const GeofenceCrossingKind = Object.freeze({
+    /**
+     * The sample sequence entered the fence.
+     */
+    Entered: 0, "0": "Entered",
+    /**
+     * The sample sequence left the fence.
+     */
+    Left: 1, "1": "Left",
+});
+exports.GeofenceCrossingKind = GeofenceCrossingKind;
+
+/**
+ * Geofence construction and evaluation error variants.
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+const GeofenceError = Object.freeze({
+    /**
+     * Fewer than three distinct vertices were supplied.
+     */
+    TooFewVertices: 0, "0": "TooFewVertices",
+    /**
+     * A geofence input value was outside its domain.
+     */
+    InvalidInput: 1, "1": "InvalidInput",
+    /**
+     * The geodesic direct or inverse calculation failed.
+     */
+    Geodesic: 2, "2": "Geodesic",
+    /**
+     * ECEF covariance rotation failed.
+     */
+    Dop: 3, "3": "Dop",
+    /**
+     * Covariance or radius validation failed.
+     */
+    ErrorMetrics: 4, "4": "ErrorMetrics",
+});
+exports.GeofenceError = GeofenceError;
+
+/**
+ * Probability integration method for geofence uncertainty.
+ * @enum {0 | 1}
+ */
+const GeofenceProbabilityMethod = Object.freeze({
+    /**
+     * Gaussian half-space approximation from boundary distance and normal variance.
+     */
+    BoundaryNormal: 0, "0": "BoundaryNormal",
+    /**
+     * Fixed quadrature over the local planarized fence.
+     */
+    PlanarQuadrature: 1, "1": "PlanarQuadrature",
+});
+exports.GeofenceProbabilityMethod = GeofenceProbabilityMethod;
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -5367,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`.
  */
@@ -12231,33 +12817,154 @@ class PreciseEphemerisSampleSource {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Predict geometric ranges for many requests in one call. See the shared
-     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
-     * this is the sample-source entry point.
-     * @param {any} requests
-     * @param {any} options
-     * @returns {any}
+     * Predict geometric ranges for many requests in one call. See the shared
+     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
+     * this is the sample-source entry point.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerissamplesource_satellites(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) PreciseEphemerisSampleSource.prototype[Symbol.dispose] = PreciseEphemerisSampleSource.prototype.free;
+exports.PreciseEphemerisSampleSource = PreciseEphemerisSampleSource;
+
+/**
+ * Evaluable precise-interpolant artifact opened from canonical store bytes.
+ */
+class PreciseInterpolantArtifact {
+    static __wrap(ptr) {
+        const obj = Object.create(PreciseInterpolantArtifact.prototype);
+        obj.__wbg_ptr = ptr;
+        PreciseInterpolantArtifactFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreciseInterpolantArtifactFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_preciseinterpolantartifact_free(ptr, 0);
+    }
+    /**
+     * Number of bytes retained by this artifact handle.
+     * @returns {number}
+     */
+    get byteLength() {
+        const ret = wasm.preciseinterpolantartifact_byteLength(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * File-level artifact checksum.
+     * @returns {bigint}
+     */
+    get checksum64() {
+        const ret = wasm.preciseinterpolantartifact_checksum64(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Evaluate one satellite state at a J2000-second epoch.
+     * @param {string} satellite
+     * @param {number} j2000_seconds
+     * @returns {Sp3State}
+     */
+    evaluate(satellite, j2000_seconds) {
+        const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.preciseinterpolantartifact_evaluate(this.__wbg_ptr, ptr0, len0, j2000_seconds);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Sp3State.__wrap(ret[0]);
+    }
+    /**
+     * Satellite tokens present in the artifact, ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseinterpolantartifact_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Artifact time scale label from the stored epoch axis.
+     * @returns {string}
+     */
+    get timeScale() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preciseinterpolantartifact_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) PreciseInterpolantArtifact.prototype[Symbol.dispose] = PreciseInterpolantArtifact.prototype.free;
+exports.PreciseInterpolantArtifact = PreciseInterpolantArtifact;
+
+/**
+ * Error category for precise-interpolant artifact open or serialization.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
+ */
+const PreciseInterpolantArtifactError = Object.freeze({
+    /**
+     * File I/O failed in the core artifact API.
+     */
+    Io: 0, "0": "Io",
+    /**
+     * Artifact bytes could not be parsed.
+     */
+    Parse: 1, "1": "Parse",
+    /**
+     * The artifact version tag is unsupported.
+     */
+    UnsupportedVersion: 2, "2": "UnsupportedVersion",
+    /**
+     * The artifact time-scale tag is unsupported.
+     */
+    UnsupportedTimeScale: 3, "3": "UnsupportedTimeScale",
+    /**
+     * A satellite-system tag is unsupported.
+     */
+    UnsupportedSatelliteSystem: 4, "4": "UnsupportedSatelliteSystem",
+    /**
+     * A satellite appears more than once in the artifact index.
+     */
+    DuplicateSatellite: 5, "5": "DuplicateSatellite",
+    /**
+     * The artifact file-level checksum did not match.
      */
-    predictRanges(requests, options) {
-        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
+    Checksum: 6, "6": "Checksum",
     /**
-     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
-     * @returns {string[]}
+     * A satellite payload checksum did not match its index record.
      */
-    get satellites() {
-        const ret = wasm.preciseephemerissamplesource_satellites(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) PreciseEphemerisSampleSource.prototype[Symbol.dispose] = PreciseEphemerisSampleSource.prototype.free;
-exports.PreciseEphemerisSampleSource = PreciseEphemerisSampleSource;
+    SatelliteChecksum: 7, "7": "SatelliteChecksum",
+});
+exports.PreciseInterpolantArtifactError = PreciseInterpolantArtifactError;
 
 /**
  * The per-request results of a batch observable prediction, index-aligned to
@@ -14352,6 +15059,240 @@ class SbasSisError {
 if (Symbol.dispose) SbasSisError.prototype[Symbol.dispose] = SbasSisError.prototype.free;
 exports.SbasSisError = SbasSisError;
 
+/**
+ * Stable GNSS signal modulation used by the analysis functions.
+ */
+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;
+exports.SignalAnalysisModulation = SignalAnalysisModulation;
+
 /**
  * Per-constellation single-frequency pseudorange code-selection policy. Build
  * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
@@ -14689,6 +15630,57 @@ class Sp3 {
         }
         return DgnssSolution.__wrap(ret[0]);
     }
+    /**
+     * Evaluate emission-time state and media corrections for index-aligned satellites.
+     *
+     * `satellites` and `emissionEpochsJ2000S` share a row count. `receiverEcefM`
+     * is `[x, y, z]` metres. Without an IONEX product this can still request
+     * troposphere corrections by passing `{ troposphere: true }`.
+     * @param {string[]} satellites
+     * @param {Float64Array} emission_epochs_j2000_s
+     * @param {Float64Array} receiver_ecef_m
+     * @param {any} options
+     * @returns {EmissionMediaBatch}
+     */
+    emissionMediaBatch(satellites, emission_epochs_j2000_s, receiver_ecef_m, options) {
+        const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(emission_epochs_j2000_s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.sp3_emissionMediaBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EmissionMediaBatch.__wrap(ret[0]);
+    }
+    /**
+     * Evaluate emission-time state plus IONEX/troposphere media corrections.
+     *
+     * `options.ionosphere` defaults to `true` on this IONEX-bearing path.
+     * `options.troposphere` defaults to `false`.
+     * @param {Ionex} ionex
+     * @param {string[]} satellites
+     * @param {Float64Array} emission_epochs_j2000_s
+     * @param {Float64Array} receiver_ecef_m
+     * @param {any} options
+     * @returns {EmissionMediaBatch}
+     */
+    emissionMediaBatchIonex(ionex, satellites, emission_epochs_j2000_s, receiver_ecef_m, options) {
+        _assertClass(ionex, Ionex);
+        const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(emission_epochs_j2000_s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.sp3_emissionMediaBatchIonex(this.__wbg_ptr, ionex.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EmissionMediaBatch.__wrap(ret[0]);
+    }
     /**
      * Number of epochs in the product.
      * @returns {number}
@@ -14787,6 +15779,19 @@ class Sp3 {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Build deterministic precise-interpolant artifact bytes from this SP3 product.
+     * @returns {Uint8Array}
+     */
+    preciseInterpolantArtifactBytes() {
+        const ret = wasm.sp3_preciseInterpolantArtifactBytes(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;
+    }
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -14850,6 +15855,40 @@ class Sp3 {
         }
         return SppBatchSolution.__wrap(ret[0]);
     }
+    /**
+     * Run SPP and attach a Doppler velocity/clock-drift solve when Doppler rows solve.
+     *
+     * `request` is the normal SPP request object. `dopplerObservations` is an
+     * array of `{ satelliteId, dopplerHz, carrierHz, satClockDriftSS? }`. The
+     * returned receiver solution carries `rxClockDriftSS` when velocity solved.
+     * @param {any} request
+     * @param {any} doppler_observations
+     * @returns {SppDopplerSolution}
+     */
+    solveSppWithDopplerVelocity(request, doppler_observations) {
+        const ret = wasm.sp3_solveSppWithDopplerVelocity(this.__wbg_ptr, request, doppler_observations);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SppDopplerSolution.__wrap(ret[0]);
+    }
+    /**
+     * Solve one static receiver position from multiple SPP-shaped epochs.
+     *
+     * `epochs` is an array of SPP request objects. `options` accepts
+     * `{ initialPositionM?, withGeodetic?, robust? }` and returns shared
+     * position, per-epoch clocks, covariance, residual, and influence surfaces.
+     * @param {any} epochs
+     * @param {any} options
+     * @returns {StaticSolution}
+     */
+    solveStatic(epochs, options) {
+        const ret = wasm.sp3_solveStatic(this.__wbg_ptr, epochs, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StaticSolution.__wrap(ret[0]);
+    }
     /**
      * Run the core robust-reweighted SPP driver under the RAIM/FDE exclusion loop.
      *
@@ -16045,11 +17084,64 @@ class SppBatchSolution {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return SppSolution.__wrap(ret[0]);
+        return SppSolution.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SppBatchSolution.prototype[Symbol.dispose] = SppBatchSolution.prototype.free;
+exports.SppBatchSolution = SppBatchSolution;
+
+/**
+ * Position solution with an optional Doppler velocity solve.
+ */
+class SppDopplerSolution {
+    static __wrap(ptr) {
+        const obj = Object.create(SppDopplerSolution.prototype);
+        obj.__wbg_ptr = ptr;
+        SppDopplerSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SppDopplerSolutionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sppdopplersolution_free(ptr, 0);
+    }
+    /**
+     * Receiver position, clock, and covariance solution.
+     * @returns {SppSolution}
+     */
+    get receiver() {
+        const ret = wasm.sppdopplersolution_receiver(this.__wbg_ptr);
+        return SppSolution.__wrap(ret);
+    }
+    /**
+     * Doppler-derived receiver velocity and clock drift, if the velocity rows solved.
+     * @returns {VelocitySolution | undefined}
+     */
+    get velocity() {
+        const ret = wasm.sppdopplersolution_velocity(this.__wbg_ptr);
+        return ret === 0 ? undefined : VelocitySolution.__wrap(ret);
+    }
+    /**
+     * Velocity-solve failure text when Doppler rows were present but unusable.
+     * @returns {string | undefined}
+     */
+    get velocityError() {
+        const ret = wasm.sppdopplersolution_velocityError(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
 }
-if (Symbol.dispose) SppBatchSolution.prototype[Symbol.dispose] = SppBatchSolution.prototype.free;
-exports.SppBatchSolution = SppBatchSolution;
+if (Symbol.dispose) SppDopplerSolution.prototype[Symbol.dispose] = SppDopplerSolution.prototype.free;
+exports.SppDopplerSolution = SppDopplerSolution;
 
 /**
  * The result of an SPP solve.
@@ -16106,6 +17198,26 @@ class SppSolution {
         const ret = wasm.sppsolution_geometryQuality(this.__wbg_ptr);
         return GeometryQuality.__wrap(ret);
     }
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEcefM2() {
+        const ret = wasm.sppsolution_positionCovarianceEcefM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEnuM2() {
+        const ret = wasm.sppsolution_positionCovarianceEnuM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      * @returns {Float64Array}
@@ -16142,6 +17254,14 @@ class SppSolution {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Receiver clock drift in seconds per second when a Doppler solve was fused.
+     * @returns {number | undefined}
+     */
+    get rxClockDriftSS() {
+        const ret = wasm.sppsolution_rxClockDriftSS(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
     /**
      * Receiver clock bias, seconds.
      * @returns {number}
@@ -16295,6 +17415,251 @@ const SsrSource = Object.freeze({
 });
 exports.SsrSource = SsrSource;
 
+/**
+ * Status for a leave-one-out static positioning diagnostic.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+const StaticInfluenceStatus = Object.freeze({
+    /**
+     * The diagnostic solve completed.
+     */
+    Solved: 0, "0": "Solved",
+    /**
+     * The omitted subset left too few measurements.
+     */
+    TooFewMeasurements: 1, "1": "TooFewMeasurements",
+    /**
+     * The diagnostic geometry was singular.
+     */
+    SingularGeometry: 2, "2": "SingularGeometry",
+    /**
+     * Input validation failed for the diagnostic subset.
+     */
+    InvalidInput: 3, "3": "InvalidInput",
+    /**
+     * Ephemeris was unavailable for the diagnostic subset.
+     */
+    EphemerisUnavailable: 4, "4": "EphemerisUnavailable",
+    /**
+     * The diagnostic subset failed for another reason.
+     */
+    SolveFailed: 5, "5": "SolveFailed",
+});
+exports.StaticInfluenceStatus = StaticInfluenceStatus;
+
+/**
+ * Multi-epoch static receiver solution.
+ */
+class StaticSolution {
+    static __wrap(ptr) {
+        const obj = Object.create(StaticSolution.prototype);
+        obj.__wbg_ptr = ptr;
+        StaticSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StaticSolutionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_staticsolution_free(ptr, 0);
+    }
+    /**
+     * `[latRad, lonRad, heightM]` when geodetic output was requested.
+     * @returns {Float64Array | undefined}
+     */
+    get geodetic() {
+        const ret = wasm.staticsolution_geodetic(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Geometry observability and covariance-validation diagnostics.
+     * @returns {GeometryQuality}
+     */
+    get geometryQuality() {
+        const ret = wasm.staticsolution_geometryQuality(this.__wbg_ptr);
+        return GeometryQuality.__wrap(ret);
+    }
+    /**
+     * Solver iteration, convergence, and redundancy metadata.
+     * @returns {any}
+     */
+    get metadata() {
+        const ret = wasm.staticsolution_metadata(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Epoch-local receiver clocks as `{ epochIndex, system, clockS }[]`.
+     * @returns {any}
+     */
+    get perEpochClocks() {
+        const ret = wasm.staticsolution_perEpochClocks(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-epoch-out diagnostics.
+     * @returns {any}
+     */
+    get perEpochInfluence() {
+        const ret = wasm.staticsolution_perEpochInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-satellite-out diagnostics across every epoch.
+     * @returns {any}
+     */
+    get perSatelliteBatchInfluence() {
+        const ret = wasm.staticsolution_perSatelliteBatchInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-satellite-out diagnostics per epoch.
+     * @returns {any}
+     */
+    get perSatelliteInfluence() {
+        const ret = wasm.staticsolution_perSatelliteInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEcefM2() {
+        const ret = wasm.staticsolution_positionCovarianceEcefM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEnuM2() {
+        const ret = wasm.staticsolution_positionCovarianceEnuM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ECEF position as `[x, y, z]`, metres.
+     * @returns {Float64Array}
+     */
+    get positionM() {
+        const ret = wasm.staticsolution_positionM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Rejected satellites grouped by input epoch.
+     * @returns {any}
+     */
+    get rejectedSats() {
+        const ret = wasm.staticsolution_rejectedSats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Root-mean-square of the unweighted post-fit residuals, metres.
+     * @returns {number}
+     */
+    get residualRmsM() {
+        const ret = wasm.staticsolution_residualRmsM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Post-fit residuals as `{ epochIndex, satelliteId, residualM, ... }[]`.
+     * @returns {any}
+     */
+    get residuals() {
+        const ret = wasm.staticsolution_residuals(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Full state covariance, flat row-major square matrix in square metres.
+     * @returns {Float64Array}
+     */
+    get stateCovarianceM2() {
+        const ret = wasm.staticsolution_stateCovarianceM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * State covariance matrix dimension.
+     * @returns {number}
+     */
+    get stateParameterCount() {
+        const ret = wasm.staticsolution_stateParameterCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Used satellite tokens grouped by input epoch.
+     * @returns {any}
+     */
+    get usedSats() {
+        const ret = wasm.staticsolution_usedSats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * ECEF X, metres.
+     * @returns {number}
+     */
+    get xM() {
+        const ret = wasm.staticsolution_xM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * ECEF Y, metres.
+     * @returns {number}
+     */
+    get yM() {
+        const ret = wasm.staticsolution_yM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * ECEF Z, metres.
+     * @returns {number}
+     */
+    get zM() {
+        const ret = wasm.staticsolution_zM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) StaticSolution.prototype[Symbol.dispose] = StaticSolution.prototype.free;
+exports.StaticSolution = StaticSolution;
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -17998,6 +19363,16 @@ class VelocitySolution {
         const ret = wasm.velocitysolution_speedMS(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Unit-variance covariance of `[vx, vy, vz, clockDrift]`, flat row-major.
+     * @returns {Float64Array}
+     */
+    get stateCovariance() {
+        const ret = wasm.velocitysolution_stateCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Satellite tokens contributing rows, in residual order.
      * @returns {string[]}
@@ -19312,6 +20687,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
@@ -19642,6 +21035,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
@@ -19759,6 +21172,25 @@ function ellipsoidalHeightM(orthometric_height_m, lat_rad, lon_rad) {
 }
 exports.ellipsoidalHeightM = ellipsoidalHeightM;
 
+/**
+ * Stable string label for an [`EmissionMediaStatus`] enum value.
+ * @param {EmissionMediaStatus} status
+ * @returns {string}
+ */
+function emissionMediaStatusLabel(status) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.emissionMediaStatusLabel(status);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.emissionMediaStatusLabel = emissionMediaStatusLabel;
+
 /**
  * Encode plain RINEX observation text into a Compact RINEX (Hatanaka) stream,
  * the inverse of [`decodeCrinex`]. RINEX 2 is emitted as CRINEX 1.0 and RINEX 3
@@ -20670,9 +22102,27 @@ function fspl(distance_km, frequency_mhz) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0];
+    return ret[0];
+}
+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.fspl = fspl;
+exports.fusionStateBytesRoundTrip = fusionStateBytesRoundTrip;
 
 /**
  * Galileo NeQuick-G single-frequency ionospheric group delay (positive metres).
@@ -20834,6 +22284,155 @@ function geodeticToEcef(geodetic) {
 }
 exports.geodeticToEcef = geodeticToEcef;
 
+/**
+ * Containment probability using default probability options.
+ * @param {Float64Array} vertices
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @param {number} height_m
+ * @param {any} uncertainty_value
+ * @returns {number}
+ */
+function geofenceContainmentProbability(vertices, lat_rad, lon_rad, height_m, uncertainty_value) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceContainmentProbability(ptr0, len0, lat_rad, lon_rad, height_m, uncertainty_value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.geofenceContainmentProbability = geofenceContainmentProbability;
+
+/**
+ * Boolean containment for one position and flat vertex array.
+ * @param {Float64Array} vertices
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @param {number} height_m
+ * @returns {boolean}
+ */
+function geofenceContains(vertices, lat_rad, lon_rad, height_m) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceContains(ptr0, len0, lat_rad, lon_rad, height_m);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.geofenceContains = geofenceContains;
+
+/**
+ * Stable string label for a [`GeofenceCrossingKind`] enum value.
+ * @param {GeofenceCrossingKind} kind
+ * @returns {string}
+ */
+function geofenceCrossingKindLabel(kind) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceCrossingKindLabel(kind);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceCrossingKindLabel = geofenceCrossingKindLabel;
+
+/**
+ * Probabilistic crossing detection with default hysteresis.
+ * @param {Float64Array} vertices
+ * @param {any} samples
+ * @param {any} options
+ * @returns {any}
+ */
+function geofenceCrossingProbability(vertices, samples, options) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceCrossingProbability(ptr0, len0, samples, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.geofenceCrossingProbability = geofenceCrossingProbability;
+
+/**
+ * Stable string label for a [`GeofenceError`] enum value.
+ * @param {GeofenceError} error
+ * @returns {string}
+ */
+function geofenceErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceErrorLabel = geofenceErrorLabel;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+ * @param {Float64Array} vertices
+ * @returns {Geofence}
+ */
+function geofenceFromVertices(vertices) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceFromVertices(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Geofence.__wrap(ret[0]);
+}
+exports.geofenceFromVertices = geofenceFromVertices;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 3D radian vertices.
+ *
+ * `vertices` is `[latRad, lonRad, heightM, ...]`. Heights are accepted but
+ * ignored by the core geofence model.
+ * @param {Float64Array} vertices
+ * @returns {Geofence}
+ */
+function geofenceFromVertices3d(vertices) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceFromVertices3d(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Geofence.__wrap(ret[0]);
+}
+exports.geofenceFromVertices3d = geofenceFromVertices3d;
+
+/**
+ * Stable string label for a [`GeofenceProbabilityMethod`] enum value.
+ * @param {GeofenceProbabilityMethod} method
+ * @returns {string}
+ */
+function geofenceProbabilityMethodLabel(method) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceProbabilityMethodLabel(method);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceProbabilityMethodLabel = geofenceProbabilityMethodLabel;
+
 /**
  * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
  * position in radians, from the COARSE built-in global grid. Latitude is
@@ -23106,6 +24705,25 @@ function oceanTideLoading(station_ecef_m, year, month, day, fractional_hour, amp
 }
 exports.oceanTideLoading = oceanTideLoading;
 
+/**
+ * Open precise-interpolant artifact bytes as an evaluable in-memory product.
+ *
+ * The returned handle owns its byte buffer because JS byte slices cannot be
+ * borrowed across calls by this class boundary.
+ * @param {Uint8Array} bytes
+ * @returns {PreciseInterpolantArtifact}
+ */
+function openPreciseInterpolantArtifact(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openPreciseInterpolantArtifact(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PreciseInterpolantArtifact.__wrap(ret[0]);
+}
+exports.openPreciseInterpolantArtifact = openPreciseInterpolantArtifact;
+
 /**
  * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
  *
@@ -23777,6 +25395,38 @@ function preciseEphemerisSamplesFromSamples(samples) {
 }
 exports.preciseEphemerisSamplesFromSamples = preciseEphemerisSamplesFromSamples;
 
+/**
+ * Compute the precise-interpolant artifact file-level checksum for byte content.
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+function preciseInterpolantArtifactChecksum64(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.preciseInterpolantArtifactChecksum64(ptr0, len0);
+    return BigInt.asUintN(64, ret);
+}
+exports.preciseInterpolantArtifactChecksum64 = preciseInterpolantArtifactChecksum64;
+
+/**
+ * Stable string label for a [`PreciseInterpolantArtifactError`] enum value.
+ * @param {PreciseInterpolantArtifactError} error
+ * @returns {string}
+ */
+function preciseInterpolantArtifactErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.preciseInterpolantArtifactErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.preciseInterpolantArtifactErrorLabel = preciseInterpolantArtifactErrorLabel;
+
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
  * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
@@ -24591,6 +26241,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.
  *
@@ -24875,6 +26553,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.
  *
@@ -25249,6 +26991,23 @@ function solveSppSbas(broadcast, store, geo, request, mode) {
 }
 exports.solveSppSbas = solveSppSbas;
 
+/**
+ * Solve one static receiver position from multiple SPP-shaped epochs over SP3.
+ * @param {Sp3} sp3
+ * @param {any} epochs
+ * @param {any} options
+ * @returns {StaticSolution}
+ */
+function solveStatic(sp3, epochs, options) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.solveStatic(sp3.__wbg_ptr, epochs, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return StaticSolution.__wrap(ret[0]);
+}
+exports.solveStatic = solveStatic;
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -25439,6 +27198,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
@@ -25492,6 +27287,25 @@ function ssrSourceLabel(source) {
 }
 exports.ssrSourceLabel = ssrSourceLabel;
 
+/**
+ * Stable string label for a [`StaticInfluenceStatus`] enum value.
+ * @param {StaticInfluenceStatus} status
+ * @returns {string}
+ */
+function staticInfluenceStatusLabel(status) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.staticInfluenceStatusLabel(status);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.staticInfluenceStatusLabel = staticInfluenceStatusLabel;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *
@@ -26303,6 +28117,10 @@ function __wbg_get_imports() {
             const ret = String.fromCodePoint(arg0 >>> 0);
             return ret;
         }, arguments); },
+        __wbg_from_13e323c65fc8f464: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
         __wbg_get_507a50627bffa49b: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -26762,6 +28580,9 @@ const Egm96FifteenMinuteGeoidFinalization = (typeof FinalizationRegistry === 'un
 const EllipsoidalHeightMFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ellipsoidalheightm_free(ptr, 1));
+const EmissionMediaBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_emissionmediabatch_free(ptr, 1));
 const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_encounterframe_free(ptr, 1));
@@ -26789,6 +28610,9 @@ const FrameScannerFinalization = (typeof FinalizationRegistry === 'undefined')
 const FrameStatesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_framestates_free(ptr, 1));
+const GeofenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_geofence_free(ptr, 1));
 const GeoidGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geoidgrid_free(ptr, 1));
@@ -26798,6 +28622,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));
@@ -27002,6 +28829,9 @@ const PreciseEphemerisInterpolantFinalization = (typeof FinalizationRegistry ===
 const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));
+const PreciseInterpolantArtifactFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseinterpolantartifact_free(ptr, 1));
 const PredictBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_predictbatch_free(ptr, 1));
@@ -27068,6 +28898,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));
@@ -27128,12 +28961,18 @@ const SpkStateFinalization = (typeof FinalizationRegistry === 'undefined')
 const SppBatchSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sppbatchsolution_free(ptr, 1));
+const SppDopplerSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sppdopplersolution_free(ptr, 1));
 const SppSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sppsolution_free(ptr, 1));
 const SsrCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ssrcorrectionstore_free(ptr, 1));
+const StaticSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_staticsolution_free(ptr, 1));
 const SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sunmoon_free(ptr, 1));