@neilberkman/sidereon 0.10.1 → 0.11.1

package/pkg/sidereon.js

@@ -726,6 +726,24 @@ export class BiasSet {
 }
 if (Symbol.dispose) BiasSet.prototype[Symbol.dispose] = BiasSet.prototype.free;
 
+/**
+ * Broadcast group-delay term selector.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
+ */
+export const BroadcastDelayTerm = Object.freeze({
+    GpsTgd: 0, "0": "GpsTgd",
+    GalileoBgdE5aE1: 1, "1": "GalileoBgdE5aE1",
+    GalileoBgdE5bE1: 2, "2": "GalileoBgdE5bE1",
+    BeidouTgd1: 3, "3": "BeidouTgd1",
+    BeidouTgd2: 4, "4": "BeidouTgd2",
+    CnavIscL1Ca: 5, "5": "CnavIscL1Ca",
+    CnavIscL2C: 6, "6": "CnavIscL2C",
+    CnavIscL5I5: 7, "7": "CnavIscL5I5",
+    CnavIscL5Q5: 8, "8": "CnavIscL5Q5",
+    CnavIscL1Cd: 9, "9": "CnavIscL1Cd",
+    CnavIscL1Cp: 10, "10": "CnavIscL1Cp",
+});
+
 /**
  * A parsed broadcast ephemeris store from a RINEX NAV file. `records` are the
  * usable GPS/Galileo/BeiDou records selected by the core default SPP policy.
@@ -807,6 +825,22 @@ export class BroadcastEphemeris {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Evaluate the store-selected broadcast state for `satellite` at GPST-like
+     * J2000 seconds. Returns `undefined` when no usable record covers the query.
+     * @param {string} satellite
+     * @param {number} t_j2000_s
+     * @returns {BroadcastStoreEvaluation | undefined}
+     */
+    evaluate(satellite, t_j2000_s) {
+        const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.broadcastephemeris_evaluate(this.__wbg_ptr, ptr0, len0, t_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : BroadcastStoreEvaluation.__wrap(ret[0]);
+    }
     /**
      * Number of usable GLONASS records.
      * @returns {number}
@@ -1005,6 +1039,45 @@ export class BroadcastEvaluation {
 }
 if (Symbol.dispose) BroadcastEvaluation.prototype[Symbol.dispose] = BroadcastEvaluation.prototype.free;
 
+/**
+ * Per-signal broadcast group-delay terms retained from a NAV record.
+ */
+export class BroadcastGroupDelaysJs {
+    static __wrap(ptr) {
+        const obj = Object.create(BroadcastGroupDelaysJs.prototype);
+        obj.__wbg_ptr = ptr;
+        BroadcastGroupDelaysJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BroadcastGroupDelaysJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_broadcastgroupdelaysjs_free(ptr, 0);
+    }
+    /**
+     * @param {CnavSignal} signal
+     * @returns {number | undefined}
+     */
+    cnavSingleFrequencyCorrectionS(signal) {
+        const ret = wasm.broadcastgroupdelaysjs_cnavSingleFrequencyCorrectionS(this.__wbg_ptr, signal);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {BroadcastDelayTerm} term
+     * @returns {number | undefined}
+     */
+    get(term) {
+        const ret = wasm.broadcastgroupdelaysjs_get(this.__wbg_ptr, term);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+}
+if (Symbol.dispose) BroadcastGroupDelaysJs.prototype[Symbol.dispose] = BroadcastGroupDelaysJs.prototype.free;
+
 /**
  * One GPS, Galileo, or BeiDou broadcast ephemeris record from RINEX NAV.
  */
@@ -1033,6 +1106,14 @@ export class BroadcastRecordJs {
         const ret = wasm.broadcastrecordjs_clock(this.__wbg_ptr);
         return ClockPolynomialJs.__wrap(ret);
     }
+    /**
+     * CNAV-family extension fields, or `undefined` for legacy records.
+     * @returns {CnavParametersJs | undefined}
+     */
+    get cnav() {
+        const ret = wasm.broadcastrecordjs_cnav(this.__wbg_ptr);
+        return ret === 0 ? undefined : CnavParametersJs.__wrap(ret);
+    }
     /**
      * Keplerian orbital elements in SI units.
      * @returns {KeplerianElementsJs}
@@ -1071,6 +1152,30 @@ export class BroadcastRecordJs {
         const ret = wasm.broadcastrecordjs_groupDelayS(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Broadcast group-delay terms carried by this record.
+     * @returns {BroadcastGroupDelaysJs}
+     */
+    get groupDelays() {
+        const ret = wasm.broadcastrecordjs_groupDelays(this.__wbg_ptr);
+        return BroadcastGroupDelaysJs.__wrap(ret);
+    }
+    /**
+     * Native issue-of-data value.
+     * @returns {number}
+     */
+    get issue() {
+        const ret = wasm.broadcastrecordjs_issue(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Message family attached to the issue-of-data value.
+     * @returns {NavMessage}
+     */
+    get issueMessage() {
+        const ret = wasm.broadcastrecordjs_issueMessage(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Broadcast message type.
      * @returns {NavMessage}
@@ -1122,6 +1227,67 @@ export class BroadcastRecordJs {
 }
 if (Symbol.dispose) BroadcastRecordJs.prototype[Symbol.dispose] = BroadcastRecordJs.prototype.free;
 
+/**
+ * Store-level broadcast ephemeris evaluation at a J2000 query epoch.
+ */
+export class BroadcastStoreEvaluation {
+    static __wrap(ptr) {
+        const obj = Object.create(BroadcastStoreEvaluation.prototype);
+        obj.__wbg_ptr = ptr;
+        BroadcastStoreEvaluationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BroadcastStoreEvaluationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_broadcaststoreevaluation_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get clockS() {
+        const ret = wasm.broadcaststoreevaluation_clockS(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get positionM() {
+        const ret = wasm.broadcaststoreevaluation_positionM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    get satellite() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.broadcaststoreevaluation_satellite(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get tJ2000S() {
+        const ret = wasm.broadcaststoreevaluation_tJ2000S(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) BroadcastStoreEvaluation.prototype[Symbol.dispose] = BroadcastStoreEvaluation.prototype.free;
+
 /**
  * A canonical GNSS carrier band. The JS value matches the variant order below.
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15}
@@ -2258,6 +2424,124 @@ export class ClockSeries {
 }
 if (Symbol.dispose) ClockSeries.prototype[Symbol.dispose] = ClockSeries.prototype.free;
 
+/**
+ * CNAV/CNAV-2 fields with no legacy LNAV counterpart.
+ */
+export class CnavParametersJs {
+    static __wrap(ptr) {
+        const obj = Object.create(CnavParametersJs.prototype);
+        obj.__wbg_ptr = ptr;
+        CnavParametersJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CnavParametersJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cnavparametersjs_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get adotMS() {
+        const ret = wasm.cnavparametersjs_adotMS(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get deltaN0DotRadS2() {
+        const ret = wasm.cnavparametersjs_deltaN0DotRadS2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get flags() {
+        const ret = wasm.cnavparametersjs_flags(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get topTowS() {
+        const ret = wasm.cnavparametersjs_topTowS(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get topWeek() {
+        const ret = wasm.cnavparametersjs_topWeek(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get transmissionTimeSow() {
+        const ret = wasm.cnavparametersjs_transmissionTimeSow(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get uraEdIndex() {
+        const ret = wasm.cnavparametersjs_uraEdIndex(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get uraNed0Index() {
+        const ret = wasm.cnavparametersjs_uraNed0Index(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get uraNed1Index() {
+        const ret = wasm.cnavparametersjs_uraNed1Index(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get uraNed2Index() {
+        const ret = wasm.cnavparametersjs_uraNed2Index(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} week
+     * @param {number} tow_s
+     * @returns {number | undefined}
+     */
+    uraNedM(week, tow_s) {
+        const ret = wasm.cnavparametersjs_uraNedM(this.__wbg_ptr, week, tow_s);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+}
+if (Symbol.dispose) CnavParametersJs.prototype[Symbol.dispose] = CnavParametersJs.prototype.free;
+
+/**
+ * GPS/QZSS signal used for CNAV inter-signal correction accessors.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+export const CnavSignal = Object.freeze({
+    L1Ca: 0, "0": "L1Ca",
+    L2C: 1, "1": "L2C",
+    L5I5: 2, "2": "L5I5",
+    L5Q5: 3, "3": "L5Q5",
+    L1Cp: 4, "4": "L1Cp",
+    L1Cd: 5, "5": "L1Cd",
+});
+
 /**
  * Collision-probability result and encounter-plane summary.
  */
@@ -2607,91 +2891,233 @@ export class CorrelationResult {
 if (Symbol.dispose) CorrelationResult.prototype[Symbol.dispose] = CorrelationResult.prototype.free;
 
 /**
- * A computed look-angle grid for a set of satellites and ground stations at one
- * epoch. Build with [`coverageLookAngles`].
+ * Propagated state plus covariance nodes.
  */
-export class CoverageGrid {
+export class CovarianceEphemeris {
     static __wrap(ptr) {
-        const obj = Object.create(CoverageGrid.prototype);
+        const obj = Object.create(CovarianceEphemeris.prototype);
         obj.__wbg_ptr = ptr;
-        CoverageGridFinalization.register(obj, obj.__wbg_ptr, obj);
+        CovarianceEphemerisFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CoverageGridFinalization.unregister(this);
+        CovarianceEphemerisFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_coveragegrid_free(ptr, 0);
-    }
-    /**
-     * Number of visible satellites per station at `minElevationDeg`, as a flat
-     * array of length `stationCount`. Delegates to
-     * `sidereon_core::astro::coverage::access_counts`.
-     * @param {number} min_elevation_deg
-     * @returns {Uint32Array}
-     */
-    accessCounts(min_elevation_deg) {
-        const ret = wasm.coveragegrid_accessCounts(this.__wbg_ptr, min_elevation_deg);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        wasm.__wbg_covarianceephemeris_free(ptr, 0);
     }
     /**
-     * The look angle for one satellite/station pair as `[azimuthDeg,
-     * elevationDeg, rangeKm]`, or `undefined` when that cell failed (the
-     * satellite was below the horizon geometry the kernel rejects) or the
-     * indices are out of range.
-     * @param {number} satellite_index
-     * @param {number} station_index
-     * @returns {Float64Array | undefined}
+     * @returns {Float64Array}
      */
-    lookAngle(satellite_index, station_index) {
-        const ret = wasm.coveragegrid_lookAngle(this.__wbg_ptr, satellite_index, station_index);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        }
+    get covariance() {
+        const ret = wasm.covarianceephemeris_covariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
     /**
-     * Maximum successful elevation per station, degrees, as a flat array of
-     * length `stationCount`. A station with no successful cell reports `NaN`.
-     * Delegates to `sidereon_core::astro::coverage::max_elevation`.
+     * @param {number} epoch_tdb_seconds
      * @returns {Float64Array}
      */
-    maxElevationDeg() {
-        const ret = wasm.coveragegrid_maxElevationDeg(this.__wbg_ptr);
+    covarianceAt(epoch_tdb_seconds) {
+        const ret = wasm.covarianceephemeris_covarianceAt(this.__wbg_ptr, epoch_tdb_seconds);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
         var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
     /**
-     * Number of satellites (grid rows).
      * @returns {number}
      */
-    get satelliteCount() {
-        const ret = wasm.coveragegrid_satelliteCount(this.__wbg_ptr);
+    get epochCount() {
+        const ret = wasm.covarianceephemeris_epochCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Number of ground stations (grid columns).
-     * @returns {number}
+     * @returns {string}
      */
-    get stationCount() {
-        const ret = wasm.coveragegrid_stationCount(this.__wbg_ptr);
-        return ret >>> 0;
+    get frame() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.covarianceephemeris_frame(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);
+        }
     }
     /**
-     * Row-major `[satellite][station]` visibility mask at `minElevationDeg`, as a
-     * flat `Uint8Array` of `1` (visible) / `0`. Error cells are not visible.
-     * Delegates to `sidereon_core::astro::coverage::visible_mask`.
-     * @param {number} min_elevation_deg
-     * @returns {Uint8Array}
+     * @returns {Float64Array}
+     */
+    get positionKm() {
+        const ret = wasm.covarianceephemeris_positionKm(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get timesS() {
+        const ret = wasm.covarianceephemeris_timesS(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get velocityKmS() {
+        const ret = wasm.covarianceephemeris_velocityKmS(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) CovarianceEphemeris.prototype[Symbol.dispose] = CovarianceEphemeris.prototype.free;
+
+/**
+ * Frame a 6x6 state covariance is expressed in.
+ * @enum {0 | 1}
+ */
+export const CovarianceFrame = Object.freeze({
+    Inertial: 0, "0": "Inertial",
+    Rtn: 1, "1": "Rtn",
+});
+
+/**
+ * Covariances returned by explicit STM transport.
+ */
+export class CovarianceTransportResult {
+    static __wrap(ptr) {
+        const obj = Object.create(CovarianceTransportResult.prototype);
+        obj.__wbg_ptr = ptr;
+        CovarianceTransportResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CovarianceTransportResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_covariancetransportresult_free(ptr, 0);
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get covariance() {
+        const ret = wasm.covariancetransportresult_covariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get nodeCount() {
+        const ret = wasm.covariancetransportresult_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) CovarianceTransportResult.prototype[Symbol.dispose] = CovarianceTransportResult.prototype.free;
+
+/**
+ * A computed look-angle grid for a set of satellites and ground stations at one
+ * epoch. Build with [`coverageLookAngles`].
+ */
+export class CoverageGrid {
+    static __wrap(ptr) {
+        const obj = Object.create(CoverageGrid.prototype);
+        obj.__wbg_ptr = ptr;
+        CoverageGridFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CoverageGridFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_coveragegrid_free(ptr, 0);
+    }
+    /**
+     * Number of visible satellites per station at `minElevationDeg`, as a flat
+     * array of length `stationCount`. Delegates to
+     * `sidereon_core::astro::coverage::access_counts`.
+     * @param {number} min_elevation_deg
+     * @returns {Uint32Array}
+     */
+    accessCounts(min_elevation_deg) {
+        const ret = wasm.coveragegrid_accessCounts(this.__wbg_ptr, min_elevation_deg);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The look angle for one satellite/station pair as `[azimuthDeg,
+     * elevationDeg, rangeKm]`, or `undefined` when that cell failed (the
+     * satellite was below the horizon geometry the kernel rejects) or the
+     * indices are out of range.
+     * @param {number} satellite_index
+     * @param {number} station_index
+     * @returns {Float64Array | undefined}
+     */
+    lookAngle(satellite_index, station_index) {
+        const ret = wasm.coveragegrid_lookAngle(this.__wbg_ptr, satellite_index, station_index);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Maximum successful elevation per station, degrees, as a flat array of
+     * length `stationCount`. A station with no successful cell reports `NaN`.
+     * Delegates to `sidereon_core::astro::coverage::max_elevation`.
+     * @returns {Float64Array}
+     */
+    maxElevationDeg() {
+        const ret = wasm.coveragegrid_maxElevationDeg(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Number of satellites (grid rows).
+     * @returns {number}
+     */
+    get satelliteCount() {
+        const ret = wasm.coveragegrid_satelliteCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of ground stations (grid columns).
+     * @returns {number}
+     */
+    get stationCount() {
+        const ret = wasm.coveragegrid_stationCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Row-major `[satellite][station]` visibility mask at `minElevationDeg`, as a
+     * flat `Uint8Array` of `1` (visible) / `0`. Error cells are not visible.
+     * Delegates to `sidereon_core::astro::coverage::visible_mask`.
+     * @param {number} min_elevation_deg
+     * @returns {Uint8Array}
      */
     visibleMask(min_elevation_deg) {
         const ret = wasm.coveragegrid_visibleMask(this.__wbg_ptr, min_elevation_deg);
@@ -3992,6 +4418,42 @@ export class GeoidGrid {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_geoidgrid_free(ptr, 0);
     }
+    /**
+     * Ellipsoidal height from orthometric height and degrees.
+     * @param {number} orthometric_height_m
+     * @param {number} lat_deg
+     * @param {number} lon_deg
+     * @returns {number}
+     */
+    ellipsoidalHeightDeg(orthometric_height_m, lat_deg, lon_deg) {
+        const ret = wasm.geoidgrid_ellipsoidalHeightDeg(this.__wbg_ptr, orthometric_height_m, lat_deg, lon_deg);
+        return ret;
+    }
+    /**
+     * Ellipsoidal height from orthometric height and radians.
+     * @param {number} orthometric_height_m
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @returns {number}
+     */
+    ellipsoidalHeightRad(orthometric_height_m, lat_rad, lon_rad) {
+        const ret = wasm.geoidgrid_ellipsoidalHeightRad(this.__wbg_ptr, orthometric_height_m, lat_rad, lon_rad);
+        return ret;
+    }
+    /**
+     * Parse an EGM96 `WW15MGH.DAC` byte buffer into a full-resolution grid.
+     * @param {Uint8Array} bytes
+     * @returns {GeoidGrid}
+     */
+    static fromEgm96Dac(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geoidgrid_fromEgm96Dac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GeoidGrid.__wrap(ret[0]);
+    }
     /**
      * Parse a grid from the documented whitespace-delimited text format (a
      * six-field header `lat_min lon_min dlat dlon n_lat n_lon` followed by
@@ -4035,6 +4497,28 @@ export class GeoidGrid {
         GeoidGridFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Orthometric height from ellipsoidal height and degrees.
+     * @param {number} ellipsoidal_height_m
+     * @param {number} lat_deg
+     * @param {number} lon_deg
+     * @returns {number}
+     */
+    orthometricHeightDeg(ellipsoidal_height_m, lat_deg, lon_deg) {
+        const ret = wasm.geoidgrid_orthometricHeightDeg(this.__wbg_ptr, ellipsoidal_height_m, lat_deg, lon_deg);
+        return ret;
+    }
+    /**
+     * Orthometric height from ellipsoidal height and radians.
+     * @param {number} ellipsoidal_height_m
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @returns {number}
+     */
+    orthometricHeightRad(ellipsoidal_height_m, lat_rad, lon_rad) {
+        const ret = wasm.geoidgrid_orthometricHeightRad(this.__wbg_ptr, ellipsoidal_height_m, lat_rad, lon_rad);
+        return ret;
+    }
     /**
      * Bilinearly interpolated undulation `N` (metres) at a geodetic position in
      * degrees (latitude positive north, longitude positive east).
@@ -4057,6 +4541,38 @@ export class GeoidGrid {
         const ret = wasm.geoidgrid_undulationRad(this.__wbg_ptr, lat_rad, lon_rad);
         return ret;
     }
+    /**
+     * Batch undulation lookup for flat `[latDeg, lonDeg, ...]` pairs.
+     * @param {Float64Array} points_deg
+     * @returns {Float64Array}
+     */
+    undulationsDeg(points_deg) {
+        const ptr0 = passArrayF64ToWasm0(points_deg, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geoidgrid_undulationsDeg(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Batch undulation lookup for flat `[latRad, lonRad, ...]` pairs.
+     * @param {Float64Array} points_rad
+     * @returns {Float64Array}
+     */
+    undulationsRad(points_rad) {
+        const ptr0 = passArrayF64ToWasm0(points_rad, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geoidgrid_undulationsRad(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
 }
 if (Symbol.dispose) GeoidGrid.prototype[Symbol.dispose] = GeoidGrid.prototype.free;
 
@@ -6563,77 +7079,341 @@ if (Symbol.dispose) NamedTle.prototype[Symbol.dispose] = NamedTle.prototype.free
 
 /**
  * Which supported RINEX NAV message a broadcast record carries.
- * @enum {0 | 1 | 2 | 3 | 4}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
  */
 export const NavMessage = Object.freeze({
     /**
      * GPS legacy LNAV.
      */
     GpsLnav: 0, "0": "GpsLnav",
+    /**
+     * GPS CNAV.
+     */
+    GpsCnav: 1, "1": "GpsCnav",
+    /**
+     * GPS CNAV-2.
+     */
+    GpsCnav2: 2, "2": "GpsCnav2",
+    /**
+     * QZSS CNAV.
+     */
+    QzssCnav: 3, "3": "QzssCnav",
+    /**
+     * QZSS CNAV-2.
+     */
+    QzssCnav2: 4, "4": "QzssCnav2",
     /**
      * Galileo I/NAV.
      */
-    GalileoInav: 1, "1": "GalileoInav",
+    GalileoInav: 5, "5": "GalileoInav",
     /**
      * Galileo F/NAV.
      */
-    GalileoFnav: 2, "2": "GalileoFnav",
+    GalileoFnav: 6, "6": "GalileoFnav",
     /**
      * BeiDou D1.
      */
-    BeidouD1: 3, "3": "BeidouD1",
+    BeidouD1: 7, "7": "BeidouD1",
     /**
      * BeiDou D2.
      */
-    BeidouD2: 4, "4": "BeidouD2",
+    BeidouD2: 8, "8": "BeidouD2",
 });
 
 /**
- * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ * Streaming NMEA epoch accumulator.
  */
-export class ObsEpoch {
-    static __wrap(ptr) {
-        const obj = Object.create(ObsEpoch.prototype);
-        obj.__wbg_ptr = ptr;
-        ObsEpochFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class NmeaAccumulator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ObsEpochFinalization.unregister(this);
+        NmeaAccumulatorFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_obsepoch_free(ptr, 0);
+        wasm.__wbg_nmeaaccumulator_free(ptr, 0);
     }
     /**
-     * Civil epoch in the file time scale.
-     * @returns {ObsEpochTime}
+     * @returns {any}
      */
-    get epoch() {
-        const ret = wasm.obsepoch_epoch(this.__wbg_ptr);
-        return ObsEpochTime.__wrap(ret);
+    finish() {
+        const ret = wasm.nmeaaccumulator_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * RINEX epoch flag. `0` is a normal observation epoch.
-     * @returns {number}
+     * @param {any} options
      */
-    get flag() {
-        const ret = wasm.obsepoch_flag(this.__wbg_ptr);
-        return ret;
+    constructor(options) {
+        const ret = wasm.nmeaaccumulator_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        NmeaAccumulatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Number of satellites present at this epoch.
-     * @returns {number}
+     * @param {Uint8Array} bytes
+     * @returns {any}
      */
-    get satelliteCount() {
-        const ret = wasm.obsepoch_satelliteCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Satellite tokens present at this epoch.
+    push(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nmeaaccumulator_push(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get retainedLength() {
+        const ret = wasm.nmeaaccumulator_retainedLength(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) NmeaAccumulator.prototype[Symbol.dispose] = NmeaAccumulator.prototype.free;
+
+/**
+ * Parsed NMEA log.
+ */
+export class NmeaParseResult {
+    static __wrap(ptr) {
+        const obj = Object.create(NmeaParseResult.prototype);
+        obj.__wbg_ptr = ptr;
+        NmeaParseResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NmeaParseResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_nmeaparseresult_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get diagnostics() {
+        const ret = wasm.nmeaparseresult_diagnostics(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.nmeaparseresult_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.nmeaparseresult_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get sentenceCount() {
+        const ret = wasm.nmeaparseresult_sentenceCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get sentences() {
+        const ret = wasm.nmeaparseresult_sentences(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) NmeaParseResult.prototype[Symbol.dispose] = NmeaParseResult.prototype.free;
+
+/**
+ * Sans-IO NTRIP client state machine.
+ */
+export class NtripClientMachine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NtripClientMachineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ntripclientmachine_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    connectionRequest() {
+        const ret = wasm.ntripclientmachine_connectionRequest(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;
+    }
+    /**
+     * @returns {any}
+     */
+    finish() {
+        const ret = wasm.ntripclientmachine_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} now_s
+     * @param {any} position
+     * @param {number} utc_seconds_of_day
+     * @returns {any}
+     */
+    ggaMessage(now_s, position, utc_seconds_of_day) {
+        const ret = wasm.ntripclientmachine_ggaMessage(this.__wbg_ptr, now_s, position, utc_seconds_of_day);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} config
+     */
+    constructor(config) {
+        const ret = wasm.ntripclientmachine_new(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        NtripClientMachineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {any}
+     */
+    push(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ntripclientmachine_push(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    reset() {
+        wasm.ntripclientmachine_reset(this.__wbg_ptr);
+    }
+    /**
+     * @returns {NtripState}
+     */
+    get state() {
+        const ret = wasm.ntripclientmachine_state(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get stateLabel() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.ntripclientmachine_stateLabel(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) NtripClientMachine.prototype[Symbol.dispose] = NtripClientMachine.prototype.free;
+
+/**
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+export const NtripState = Object.freeze({
+    Idle: 0, "0": "Idle",
+    AwaitingStatus: 1, "1": "AwaitingStatus",
+    AwaitingHeaders: 2, "2": "AwaitingHeaders",
+    Streaming: 3, "3": "Streaming",
+    Sourcetable: 4, "4": "Sourcetable",
+    Closed: 5, "5": "Closed",
+});
+
+/**
+ * @enum {0 | 1}
+ */
+export const NtripVersion = Object.freeze({
+    Rev1: 0, "0": "Rev1",
+    Rev2: 1, "1": "Rev2",
+});
+
+/**
+ * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ */
+export class ObsEpoch {
+    static __wrap(ptr) {
+        const obj = Object.create(ObsEpoch.prototype);
+        obj.__wbg_ptr = ptr;
+        ObsEpochFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ObsEpochFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_obsepoch_free(ptr, 0);
+    }
+    /**
+     * Civil epoch in the file time scale.
+     * @returns {ObsEpochTime}
+     */
+    get epoch() {
+        const ret = wasm.obsepoch_epoch(this.__wbg_ptr);
+        return ObsEpochTime.__wrap(ret);
+    }
+    /**
+     * RINEX epoch flag. `0` is a normal observation epoch.
+     * @returns {number}
+     */
+    get flag() {
+        const ret = wasm.obsepoch_flag(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Number of satellites present at this epoch.
+     * @returns {number}
+     */
+    get satelliteCount() {
+        const ret = wasm.obsepoch_satelliteCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Satellite tokens present at this epoch.
      * @returns {string[]}
      */
     get satellites() {
@@ -6988,6 +7768,224 @@ export const ObservationKind = Object.freeze({
     Unknown: 4, "4": "Unknown",
 });
 
+/**
+ * Aggregate observation QC report.
+ */
+export class ObservationQcReport {
+    static __wrap(ptr) {
+        const obj = Object.create(ObservationQcReport.prototype);
+        obj.__wbg_ptr = ptr;
+        ObservationQcReportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ObservationQcReportFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_observationqcreport_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get clockJumps() {
+        const ret = wasm.observationqcreport_clockJumps(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get cycleSlips() {
+        const ret = wasm.observationqcreport_cycleSlips(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get dataGaps() {
+        const ret = wasm.observationqcreport_dataGaps(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get eventRecords() {
+        const ret = wasm.observationqcreport_eventRecords(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get intervalS() {
+        const ret = wasm.observationqcreport_intervalS(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @returns {string}
+     */
+    get intervalSource() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.observationqcreport_intervalSource(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get missingEpochs() {
+        const ret = wasm.observationqcreport_missingEpochs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get multipath() {
+        const ret = wasm.observationqcreport_multipath(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get notes() {
+        const ret = wasm.observationqcreport_notes(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get observationEpochs() {
+        const ret = wasm.observationqcreport_observationEpochs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get powerFailureEpochs() {
+        const ret = wasm.observationqcreport_powerFailureEpochs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    renderHtml() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.observationqcreport_renderHtml(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    renderText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.observationqcreport_renderText(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    get satelliteSignals() {
+        const ret = wasm.observationqcreport_satelliteSignals(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get satellites() {
+        const ret = wasm.observationqcreport_satellites(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get skippedRecords() {
+        const ret = wasm.observationqcreport_skippedRecords(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get systemSignals() {
+        const ret = wasm.observationqcreport_systemSignals(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toJson() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.observationqcreport_toJson(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get totalEpochRecords() {
+        const ret = wasm.observationqcreport_totalEpochRecords(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ObservationQcReport.prototype[Symbol.dispose] = ObservationQcReport.prototype.free;
+
 /**
  * Flattened raw observation rows from one RINEX OBS epoch. Numeric arrays are
  * row-aligned with `satellites`, `codes`, and `kinds`; blank RINEX values, LLI,
@@ -8083,6 +9081,14 @@ export class OmmEpoch {
         const ret = wasm.ommepoch_day(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Femtosecond remainder within the microsecond.
+     * @returns {number}
+     */
+    get femtosecond() {
+        const ret = wasm.ommepoch_femtosecond(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Hour of day.
      * @returns {number}
@@ -8141,9 +9147,10 @@ export class OmmEpoch {
      * @param {number} minute
      * @param {number} second
      * @param {number} microsecond
+     * @param {number | null} [femtosecond]
      */
-    constructor(year, month, day, hour, minute, second, microsecond) {
-        const ret = wasm.ommepoch_new(year, month, day, hour, minute, second, microsecond);
+    constructor(year, month, day, hour, minute, second, microsecond, femtosecond) {
+        const ret = wasm.ommepoch_new(year, month, day, hour, minute, second, microsecond, isLikeNone(femtosecond) ? Number.MAX_SAFE_INTEGER : (femtosecond) >>> 0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -10225,44 +11232,125 @@ export class RinexClock {
      * Satellite tokens with at least one parsed `AS` clock sample.
      * @returns {string[]}
      */
-    get satellites() {
-        const ret = wasm.rinexclock_satellites(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    get satellites() {
+        const ret = wasm.rinexclock_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Per-satellite clock-bias series in satellite sort order.
+     * @returns {ClockSeries[]}
+     */
+    get series() {
+        const ret = wasm.rinexclock_series(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * One satellite's clock series, or `undefined` if the satellite is absent.
+     * @param {string} satellite_id
+     * @returns {ClockSeries | undefined}
+     */
+    seriesFor(satellite_id) {
+        const ptr0 = passStringToWasm0(satellite_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rinexclock_seriesFor(this.__wbg_ptr, ptr0, len0);
+        return ret === 0 ? undefined : ClockSeries.__wrap(ret);
+    }
+    /**
+     * Serialize to standard RINEX clock text. Deterministic: the same product
+     * always produces byte-identical text, and re-parsing the output reproduces
+     * the same time scale and per-satellite bias series.
+     * @returns {string}
+     */
+    toRinexString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rinexclock_toRinexString(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) RinexClock.prototype[Symbol.dispose] = RinexClock.prototype.free;
+
+/**
+ * Navigation repair result.
+ */
+export class RinexNavRepair {
+    static __wrap(ptr) {
+        const obj = Object.create(RinexNavRepair.prototype);
+        obj.__wbg_ptr = ptr;
+        RinexNavRepairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RinexNavRepairFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rinexnavrepair_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get actions() {
+        const ret = wasm.rinexnavrepair_actions(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IonoCorrectionsJs | undefined}
+     */
+    get iono() {
+        const ret = wasm.rinexnavrepair_iono(this.__wbg_ptr);
+        return ret === 0 ? undefined : IonoCorrectionsJs.__wrap(ret);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get leapSeconds() {
+        const ret = wasm.rinexnavrepair_leapSeconds(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
     }
     /**
-     * Per-satellite clock-bias series in satellite sort order.
-     * @returns {ClockSeries[]}
+     * @returns {BroadcastRecordJs[]}
      */
-    get series() {
-        const ret = wasm.rinexclock_series(this.__wbg_ptr);
+    get records() {
+        const ret = wasm.rinexnavrepair_records(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * One satellite's clock series, or `undefined` if the satellite is absent.
-     * @param {string} satellite_id
-     * @returns {ClockSeries | undefined}
+     * @returns {any}
      */
-    seriesFor(satellite_id) {
-        const ptr0 = passStringToWasm0(satellite_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rinexclock_seriesFor(this.__wbg_ptr, ptr0, len0);
-        return ret === 0 ? undefined : ClockSeries.__wrap(ret);
+    get remaining() {
+        const ret = wasm.rinexnavrepair_remaining(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Serialize to standard RINEX clock text. Deterministic: the same product
-     * always produces byte-identical text, and re-parsing the output reproduces
-     * the same time scale and per-satellite bias series.
      * @returns {string}
      */
-    toRinexString() {
+    get repairedText() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.rinexclock_toRinexString(this.__wbg_ptr);
+            const ret = wasm.rinexnavrepair_repairedText(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -10271,7 +11359,7 @@ export class RinexClock {
         }
     }
 }
-if (Symbol.dispose) RinexClock.prototype[Symbol.dispose] = RinexClock.prototype.free;
+if (Symbol.dispose) RinexNavRepair.prototype[Symbol.dispose] = RinexNavRepair.prototype.free;
 
 /**
  * A parsed RINEX 3/4 observation file.
@@ -10417,6 +11505,143 @@ export class RinexObs {
 }
 if (Symbol.dispose) RinexObs.prototype[Symbol.dispose] = RinexObs.prototype.free;
 
+/**
+ * Observation repair result.
+ */
+export class RinexObsRepair {
+    static __wrap(ptr) {
+        const obj = Object.create(RinexObsRepair.prototype);
+        obj.__wbg_ptr = ptr;
+        RinexObsRepairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RinexObsRepairFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rinexobsrepair_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get actions() {
+        const ret = wasm.rinexobsrepair_actions(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get decodedFromCrinex() {
+        const ret = wasm.rinexobsrepair_decodedFromCrinex(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get remaining() {
+        const ret = wasm.rinexobsrepair_remaining(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {RinexObs}
+     */
+    get repaired() {
+        const ret = wasm.rinexobsrepair_repaired(this.__wbg_ptr);
+        return RinexObs.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get repairedText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rinexobsrepair_repairedText(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    toCrinexString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.rinexobsrepair_toCrinexString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RinexObsRepair.prototype[Symbol.dispose] = RinexObsRepair.prototype.free;
+
+/**
+ * Stateful MSM lock-time tracker for deriving RINEX LLI continuity bits.
+ */
+export class RtcmLockTimeTracker {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RtcmLockTimeTrackerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rtcmlocktimetracker_free(ptr, 0);
+    }
+    /**
+     * Build an empty tracker.
+     */
+    constructor() {
+        const ret = wasm.rtcmlocktimetracker_new();
+        this.__wbg_ptr = ret;
+        RtcmLockTimeTrackerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Derive LLI rows for one decoded MSM message object and advance state.
+     * @param {any} message
+     * @returns {any}
+     */
+    observe(message) {
+        const ret = wasm.rtcmlocktimetracker_observe(this.__wbg_ptr, message);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Drop all per-cell lock history.
+     */
+    reset() {
+        wasm.rtcmlocktimetracker_reset(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) RtcmLockTimeTracker.prototype[Symbol.dispose] = RtcmLockTimeTracker.prototype.free;
+
 /**
  * Validated fixed RTK baseline solution.
  */
@@ -11823,86 +13048,242 @@ export class SpaceWeather {
     /**
      * @returns {number}
      */
-    get ap() {
-        const ret = wasm.spaceweather_ap(this.__wbg_ptr);
-        return ret;
+    get ap() {
+        const ret = wasm.spaceweather_ap(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get f107() {
+        const ret = wasm.spaceweather_f107(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get f107a() {
+        const ret = wasm.spaceweather_f107a(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number | null} [f107]
+     * @param {number | null} [f107a]
+     * @param {number | null} [ap]
+     */
+    constructor(f107, f107a, ap) {
+        const ret = wasm.spaceweather_new(!isLikeNone(f107), isLikeNone(f107) ? 0 : f107, !isLikeNone(f107a), isLikeNone(f107a) ? 0 : f107a, !isLikeNone(ap), isLikeNone(ap) ? 0 : ap);
+        this.__wbg_ptr = ret;
+        SpaceWeatherFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) SpaceWeather.prototype[Symbol.dispose] = SpaceWeather.prototype.free;
+
+/**
+ * Canonical quiet-Sun space-weather indices for NRLMSISE-00, mirrored from the
+ * core so a JS caller can pass moderate-activity defaults to [`atmosphereDensity`]
+ * without re-deriving the magic numbers.
+ */
+export class SpaceWeatherDefaults {
+    static __wrap(ptr) {
+        const obj = Object.create(SpaceWeatherDefaults.prototype);
+        obj.__wbg_ptr = ptr;
+        SpaceWeatherDefaultsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpaceWeatherDefaultsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spaceweatherdefaults_free(ptr, 0);
+    }
+    /**
+     * Daily magnetic Ap index.
+     * @returns {number}
+     */
+    get ap() {
+        const ret = wasm.spaceweatherdefaults_ap(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Daily F10.7 solar radio flux.
+     * @returns {number}
+     */
+    get f107() {
+        const ret = wasm.spaceweatherdefaults_f107(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 81-day centred F10.7 average.
+     * @returns {number}
+     */
+    get f107a() {
+        const ret = wasm.spaceweatherdefaults_f107a(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SpaceWeatherDefaults.prototype[Symbol.dispose] = SpaceWeatherDefaults.prototype.free;
+
+/**
+ * Parsed CelesTrak CSSI space-weather table.
+ */
+export class SpaceWeatherTable {
+    static __wrap(ptr) {
+        const obj = Object.create(SpaceWeatherTable.prototype);
+        obj.__wbg_ptr = ptr;
+        SpaceWeatherTableFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpaceWeatherTableFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spaceweathertable_free(ptr, 0);
+    }
+    /**
+     * @param {number} epoch_j2000_s
+     * @returns {Float64Array}
+     */
+    apArrayAt(epoch_j2000_s) {
+        const ret = wasm.spaceweathertable_apArrayAt(this.__wbg_ptr, epoch_j2000_s);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {any}
+     */
+    get coverage() {
+        const ret = wasm.spaceweathertable_coverage(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} year
+     * @param {number} month
+     * @param {number} day
+     * @returns {any}
+     */
+    day(year, month, day) {
+        const ret = wasm.spaceweathertable_day(this.__wbg_ptr, year, month, day);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get dayCount() {
+        const ret = wasm.spaceweathertable_dayCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * @returns {number}
+     * @returns {any}
      */
-    get f107() {
-        const ret = wasm.spaceweather_f107(this.__wbg_ptr);
-        return ret;
+    days() {
+        const ret = wasm.spaceweathertable_days(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {number}
+     * @returns {any}
      */
-    get f107a() {
-        const ret = wasm.spaceweather_f107a(this.__wbg_ptr);
-        return ret;
+    get diagnostics() {
+        const ret = wasm.spaceweathertable_diagnostics(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @param {number | null} [f107]
-     * @param {number | null} [f107a]
-     * @param {number | null} [ap]
+     * @returns {any}
      */
-    constructor(f107, f107a, ap) {
-        const ret = wasm.spaceweather_new(!isLikeNone(f107), isLikeNone(f107) ? 0 : f107, !isLikeNone(f107a), isLikeNone(f107a) ? 0 : f107a, !isLikeNone(ap), isLikeNone(ap) ? 0 : ap);
-        this.__wbg_ptr = ret;
-        SpaceWeatherFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) SpaceWeather.prototype[Symbol.dispose] = SpaceWeather.prototype.free;
-
-/**
- * Canonical quiet-Sun space-weather indices for NRLMSISE-00, mirrored from the
- * core so a JS caller can pass moderate-activity defaults to [`atmosphereDensity`]
- * without re-deriving the magic numbers.
- */
-export class SpaceWeatherDefaults {
-    static __wrap(ptr) {
-        const obj = Object.create(SpaceWeatherDefaults.prototype);
-        obj.__wbg_ptr = ptr;
-        SpaceWeatherDefaultsFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    monthly() {
+        const ret = wasm.spaceweathertable_monthly(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SpaceWeatherDefaultsFinalization.unregister(this);
-        return ptr;
+    /**
+     * @returns {number}
+     */
+    get monthlyCount() {
+        const ret = wasm.spaceweathertable_monthlyCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_spaceweatherdefaults_free(ptr, 0);
+    /**
+     * @param {number} epoch_j2000_s
+     * @param {any} policy
+     * @returns {any}
+     */
+    sampleAt(epoch_j2000_s, policy) {
+        const ret = wasm.spaceweathertable_sampleAt(this.__wbg_ptr, epoch_j2000_s, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Daily magnetic Ap index.
-     * @returns {number}
+     * @param {number} epoch_j2000_s
+     * @returns {any}
      */
-    get ap() {
-        const ret = wasm.spaceweatherdefaults_ap(this.__wbg_ptr);
-        return ret;
+    spaceWeatherAt(epoch_j2000_s) {
+        const ret = wasm.spaceweathertable_spaceWeatherAt(this.__wbg_ptr, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Daily F10.7 solar radio flux.
-     * @returns {number}
+     * @returns {string}
      */
-    get f107() {
-        const ret = wasm.spaceweatherdefaults_f107(this.__wbg_ptr);
-        return ret;
+    toCsv() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.spaceweathertable_toCsv(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);
+        }
     }
     /**
-     * 81-day centred F10.7 average.
-     * @returns {number}
+     * @returns {string}
      */
-    get f107a() {
-        const ret = wasm.spaceweatherdefaults_f107a(this.__wbg_ptr);
-        return ret;
+    toTxt() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.spaceweathertable_toTxt(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) SpaceWeatherDefaults.prototype[Symbol.dispose] = SpaceWeatherDefaults.prototype.free;
+if (Symbol.dispose) SpaceWeatherTable.prototype[Symbol.dispose] = SpaceWeatherTable.prototype.free;
 
 /**
  * A parsed in-memory JPL/NAIF SPK kernel.
@@ -12887,6 +14268,95 @@ export class Tle {
 }
 if (Symbol.dispose) Tle.prototype[Symbol.dispose] = Tle.prototype.free;
 
+/**
+ * Result of fitting a TLE to TEME samples.
+ */
+export class TleFit {
+    static __wrap(ptr) {
+        const obj = Object.create(TleFit.prototype);
+        obj.__wbg_ptr = ptr;
+        TleFitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TleFitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tlefit_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get elements() {
+        const ret = wasm.tlefit_elements(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get line1() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tlefit_line1(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get line2() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tlefit_line2(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Omm}
+     */
+    get omm() {
+        const ret = wasm.tlefit_omm(this.__wbg_ptr);
+        return Omm.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    get stats() {
+        const ret = wasm.tlefit_stats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string[]}
+     */
+    toLines() {
+        const ret = wasm.tlefit_toLines(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TleFit.prototype[Symbol.dispose] = TleFit.prototype.free;
+
 /**
  * TEME states from a batched SGP4 propagation. Each array is flat row-major,
  * length `3 * epochCount`.
@@ -13621,6 +15091,16 @@ export function cn0(eirp_dbw, fspl_db, receiver_gt_dbk, other_losses_db) {
     return ret[0];
 }
 
+/**
+ * Nominal GPS/QZSS CNAV URA meters for an ED/NED0 index.
+ * @param {number} index
+ * @returns {number | undefined}
+ */
+export function cnavUraNominalM(index) {
+    const ret = wasm.cnavUraNominalM(index);
+    return ret[0] === 0 ? undefined : ret[1];
+}
+
 /**
  * @param {any} coe
  * @param {RetrogradeFactor | null} [factor]
@@ -13954,6 +15434,26 @@ export function decodeRtcmMessage(body) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Decode an RTCM 3 byte stream into messages plus stream diagnostics.
+ *
+ * The `messages` array has the same object form as [`decodeRtcm`].
+ * `diagnostics.resyncBytes` counts skipped bytes while finding valid frames,
+ * and `diagnostics.skippedFrames` reports CRC-valid frames whose bodies could
+ * not be decoded.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function decodeRtcmStream(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decodeRtcmStream(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {Uint8Array} bytes
  * @param {string | null} [form]
@@ -14320,6 +15820,40 @@ export function egm96Undulation(lat_rad, lon_rad) {
     return ret;
 }
 
+/**
+ * Batch EGM96 undulation lookup for flat `[latDeg, lonDeg, ...]` pairs.
+ * @param {Float64Array} points_deg
+ * @returns {Float64Array}
+ */
+export function egm96UndulationsDeg(points_deg) {
+    const ptr0 = passArrayF64ToWasm0(points_deg, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.egm96UndulationsDeg(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Batch EGM96 undulation lookup for flat `[latRad, lonRad, ...]` pairs.
+ * @param {Float64Array} points_rad
+ * @returns {Float64Array}
+ */
+export function egm96UndulationsRad(points_rad) {
+    const ptr0 = passArrayF64ToWasm0(points_rad, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.egm96UndulationsRad(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Effective isotropic radiated power, dBW.
  * @param {number} tx_power_dbm
@@ -14532,6 +16066,23 @@ export function estimateDecay(drag, request) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Estimate decay using per-epoch values from a parsed space-weather table.
+ * @param {DragForce} drag
+ * @param {SpaceWeatherTable} table
+ * @param {any} request
+ * @returns {any}
+ */
+export function estimateDecayWithSpaceWeather(drag, table, request) {
+    _assertClass(drag, DragForce);
+    _assertClass(table, SpaceWeatherTable);
+    const ret = wasm.estimateDecayWithSpaceWeather(drag.__wbg_ptr, table.__wbg_ptr, request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -14772,13 +16323,27 @@ export function fitReducedOrbitSp3(sp3, satellite, options) {
  * @param {any} options
  * @returns {ReducedOrbitSourceFit}
  */
-export function fitReducedOrbitTle(tle, options) {
-    _assertClass(tle, Tle);
-    const ret = wasm.fitReducedOrbitTle(tle.__wbg_ptr, options);
+export function fitReducedOrbitTle(tle, options) {
+    _assertClass(tle, Tle);
+    const ret = wasm.fitReducedOrbitTle(tle.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ReducedOrbitSourceFit.__wrap(ret[0]);
+}
+
+/**
+ * Fit SGP4 mean elements and optional B* to TEME state samples.
+ * @param {any} samples
+ * @param {any} config
+ * @returns {TleFit}
+ */
+export function fitTle(samples, config) {
+    const ret = wasm.fitTle(samples, config);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ReducedOrbitSourceFit.__wrap(ret[0]);
+    return TleFit.__wrap(ret[0]);
 }
 
 /**
@@ -15025,6 +16590,42 @@ export function geoidUndulation(lat_rad, lon_rad) {
     return ret;
 }
 
+/**
+ * Batch coarse built-in undulation lookup for flat `[latDeg, lonDeg, ...]`
+ * pairs.
+ * @param {Float64Array} points_deg
+ * @returns {Float64Array}
+ */
+export function geoidUndulationsDeg(points_deg) {
+    const ptr0 = passArrayF64ToWasm0(points_deg, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geoidUndulationsDeg(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Batch coarse built-in undulation lookup for flat `[latRad, lonRad, ...]`
+ * pairs.
+ * @param {Float64Array} points_rad
+ * @returns {Float64Array}
+ */
+export function geoidUndulationsRad(points_rad) {
+    const ptr0 = passArrayF64ToWasm0(points_rad, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geoidUndulationsRad(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Geometry-free phase combination `L_GF = L1 - L2`, metres.
  * @param {number} l1_m
@@ -15752,6 +17353,36 @@ export function leastSquaresDropOne(request) {
     return LeastSquaresDropOneReport.__wrap(ret[0]);
 }
 
+/**
+ * Lint RINEX navigation text.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function lintRinexNav(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lintRinexNav(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Lint RINEX observation text.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function lintRinexObs(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lintRinexObs(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Decode LNAV subframes 1-3 back into engineering-unit parameters.
  *
@@ -16503,6 +18134,45 @@ export function nequickGStecTecu(_eval) {
     return ret[0];
 }
 
+/**
+ * Parse bytes and return grouped epoch snapshots directly.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function nmeaEpochs(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nmeaEpochs(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Write a GGA sentence from a JS object.
+ * @param {any} request
+ * @returns {string}
+ */
+export function nmeaWriteGga(request) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.nmeaWriteGga(request);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Equal-variance noise amplification of the ionosphere-free combination.
  * @param {number} f1_hz
@@ -16547,6 +18217,21 @@ export function normalCovariance(jacobian, m, n, variance_scale) {
     return v2;
 }
 
+/**
+ * Build the NTRIP connection request bytes for a config object.
+ * @param {any} config
+ * @returns {Uint8Array}
+ */
+export function ntripRequestBytes(config) {
+    const ret = wasm.ntripRequestBytes(config);
+    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 observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -16612,6 +18297,21 @@ export function observationKindLabel(kind) {
     }
 }
 
+/**
+ * Aggregate observation QC for a parsed RINEX OBS product.
+ * @param {RinexObs} obs
+ * @param {any} options
+ * @returns {ObservationQcReport}
+ */
+export function observationQc(obs, options) {
+    _assertClass(obs, RinexObs);
+    const ret = wasm.observationQc(obs.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ObservationQcReport.__wrap(ret[0]);
+}
+
 /**
  * Observe `"sun"` or `"moon"` from a geodetic station at a UTC unix microsecond epoch.
  * @param {any} station
@@ -16787,6 +18487,33 @@ export function parseNavcen(html) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Parse NMEA sentences from bytes.
+ * @param {Uint8Array} bytes
+ * @returns {NmeaParseResult}
+ */
+export function parseNmea(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseNmea(ptr0, len0);
+    return NmeaParseResult.__wrap(ret);
+}
+
+/**
+ * Parse NTRIP sourcetable text from UTF-8 bytes.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function parseNtripSourcetable(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseNtripSourcetable(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Parse CCSDS OEM KVN text. The KVN reader is forgiving: malformed ephemeris
  * lines are skipped and counted in `skippedStates`. Throws an `Error` on a
@@ -17023,6 +18750,51 @@ export function parseRinexObs(bytes) {
     return RinexObs.__wrap(ret[0]);
 }
 
+/**
+ * Parse either CSV or fixed-width TXT space-weather bytes.
+ * @param {Uint8Array} bytes
+ * @returns {SpaceWeatherTable}
+ */
+export function parseSpaceWeather(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseSpaceWeather(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SpaceWeatherTable.__wrap(ret[0]);
+}
+
+/**
+ * Parse CelesTrak CSSI CSV space-weather text.
+ * @param {string} text
+ * @returns {SpaceWeatherTable}
+ */
+export function parseSpaceWeatherCsv(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseSpaceWeatherCsv(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SpaceWeatherTable.__wrap(ret[0]);
+}
+
+/**
+ * Parse CelesTrak CSSI fixed-width TXT space-weather text.
+ * @param {string} text
+ * @returns {SpaceWeatherTable}
+ */
+export function parseSpaceWeatherTxt(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseSpaceWeatherTxt(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SpaceWeatherTable.__wrap(ret[0]);
+}
+
 /**
  * Parse a multi-record TLE file (CelesTrak / Space-Track style) into named,
  * initialized [`Tle`] instances. Handles bare 2-line sets, 3-line name+line1+line2
@@ -17306,6 +19078,19 @@ export function propagateBatch(satellites, epochs_unix_us) {
     return FleetPropagation.__wrap(ret[0]);
 }
 
+/**
+ * Propagate an ECI Cartesian state and 6x6 covariance to requested epochs.
+ * @param {any} request
+ * @returns {CovarianceEphemeris}
+ */
+export function propagateCovariance(request) {
+    const ret = wasm.propagateCovariance(request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CovarianceEphemeris.__wrap(ret[0]);
+}
+
 /**
  * @param {any} coe
  * @param {number} mu_km3_s2
@@ -17421,6 +19206,38 @@ export function relativeState(chief, deputy) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Repair RINEX navigation text.
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {RinexNavRepair}
+ */
+export function repairRinexNav(bytes, options) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.repairRinexNav(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RinexNavRepair.__wrap(ret[0]);
+}
+
+/**
+ * Repair RINEX observation text.
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {RinexObsRepair}
+ */
+export function repairRinexObs(bytes, options) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.repairRinexObs(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RinexObsRepair.__wrap(ret[0]);
+}
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  * @param {bigint} prn
@@ -17509,6 +19326,37 @@ export function rswRotation(position_km, velocity_km_s) {
     return v3;
 }
 
+/**
+ * Derive a RINEX LLI value for one MSM signal cell.
+ *
+ * `previous` is `null`/`undefined` or `{ elapsedMs, minLockTimeMs? }`.
+ * `currentMinLockTimeMs` is a number or `null`/`undefined` for reserved current
+ * indicators.
+ * @param {any} previous
+ * @param {any} current_min_lock_time_ms
+ * @param {boolean} half_cycle_ambiguity
+ * @returns {number}
+ */
+export function rtcmDeriveLli(previous, current_min_lock_time_ms, half_cycle_ambiguity) {
+    const ret = wasm.rtcmDeriveLli(previous, current_min_lock_time_ms, half_cycle_ambiguity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * RINEX LLI bit constants used by the RTCM MSM LLI helpers.
+ * @returns {any}
+ */
+export function rtcmLliBits() {
+    const ret = wasm.rtcmLliBits();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Read the 12-bit RTCM message number from a message body.
  *
@@ -17527,6 +19375,59 @@ export function rtcmMessageNumber(body) {
     return ret[0];
 }
 
+/**
+ * Minimum continuous-lock time encoded by an MSM4/7 lock-time indicator.
+ *
+ * `kind` is `"msm4"` or `"msm7"`. Reserved or out-of-range indicators return
+ * `undefined`.
+ * @param {string} kind
+ * @param {number} indicator
+ * @returns {any}
+ */
+export function rtcmMinimumLockTimeMs(kind, indicator) {
+    const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rtcmMinimumLockTimeMs(ptr0, len0, indicator);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Elapsed milliseconds between two raw MSM epoch-time fields.
+ * @param {string} system
+ * @param {number} previous_epoch_time
+ * @param {number} current_epoch_time
+ * @returns {number}
+ */
+export function rtcmMsmEpochDtMs(system, previous_epoch_time, current_epoch_time) {
+    const ptr0 = passStringToWasm0(system, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rtcmMsmEpochDtMs(ptr0, len0, previous_epoch_time, current_epoch_time);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * RINEX 3 observation-code suffix for an MSM signal id, or `undefined` for
+ * reserved ids.
+ * @param {string} system
+ * @param {number} signal_id
+ * @returns {any}
+ */
+export function rtcmMsmSignalRinexCode(system, signal_id) {
+    const ptr0 = passStringToWasm0(system, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rtcmMsmSignalRinexCode(ptr0, len0, signal_id);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {Float64Array} position_km
  * @param {Float64Array} velocity_km_s
@@ -18751,6 +20652,23 @@ export function toCsv(records, booleans) {
     }
 }
 
+/**
+ * Transport a 6x6 covariance through caller-supplied STM segments.
+ * @param {Float64Array} covariance
+ * @param {any} segments
+ * @param {any} options
+ * @returns {CovarianceTransportResult}
+ */
+export function transportCovariance(covariance, segments, options) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.transportCovariance(ptr0, len0, segments, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CovarianceTransportResult.__wrap(ret[0]);
+}
+
 /**
  * Niell hydrostatic and wet mapping factors at an elevation.
  *
@@ -19114,6 +21032,10 @@ function __wbg_get_imports() {
             const ret = FleetPass.__wrap(arg0);
             return ret;
         },
+        __wbg_fromCodePoint_a952b701bbb83fa4: function() { return handleError(function (arg0) {
+            const ret = String.fromCodePoint(arg0 >>> 0);
+            return ret;
+        }, arguments); },
         __wbg_get_507a50627bffa49b: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -19446,9 +21368,15 @@ const BroadcastEphemerisFinalization = (typeof FinalizationRegistry === 'undefin
 const BroadcastEvaluationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_broadcastevaluation_free(ptr, 1));
+const BroadcastGroupDelaysJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_broadcastgroupdelaysjs_free(ptr, 1));
 const BroadcastRecordJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_broadcastrecordjs_free(ptr, 1));
+const BroadcastStoreEvaluationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_broadcaststoreevaluation_free(ptr, 1));
 const CarrierPairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_carrierpair_free(ptr, 1));
@@ -19476,6 +21404,9 @@ const ClockPolynomialJsFinalization = (typeof FinalizationRegistry === 'undefine
 const ClockSeriesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clockseries_free(ptr, 1));
+const CnavParametersJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cnavparametersjs_free(ptr, 1));
 const CollisionProbabilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_collisionprobability_free(ptr, 1));
@@ -19488,6 +21419,12 @@ const ConstellationFinalization = (typeof FinalizationRegistry === 'undefined')
 const CorrelationResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_correlationresult_free(ptr, 1));
+const CovarianceEphemerisFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_covarianceephemeris_free(ptr, 1));
+const CovarianceTransportResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_covariancetransportresult_free(ptr, 1));
 const CoverageGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_coveragegrid_free(ptr, 1));
@@ -19635,6 +21572,15 @@ const MovingBaselineSolutionFinalization = (typeof FinalizationRegistry === 'und
 const NamedTleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_namedtle_free(ptr, 1));
+const NmeaAccumulatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nmeaaccumulator_free(ptr, 1));
+const NmeaParseResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nmeaparseresult_free(ptr, 1));
+const NtripClientMachineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ntripclientmachine_free(ptr, 1));
 const ObsEpochFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_obsepoch_free(ptr, 1));
@@ -19650,6 +21596,9 @@ const ObsPhaseShiftFinalization = (typeof FinalizationRegistry === 'undefined')
 const ObservationFilterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_observationfilter_free(ptr, 1));
+const ObservationQcReportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_observationqcreport_free(ptr, 1));
 const ObservationValueSeriesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_observationvalueseries_free(ptr, 1));
@@ -19740,9 +21689,18 @@ const ReducedOrbitStateFinalization = (typeof FinalizationRegistry === 'undefine
 const RinexClockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rinexclock_free(ptr, 1));
+const RinexNavRepairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rinexnavrepair_free(ptr, 1));
 const RinexObsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rinexobs_free(ptr, 1));
+const RinexObsRepairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rinexobsrepair_free(ptr, 1));
+const RtcmLockTimeTrackerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rtcmlocktimetracker_free(ptr, 1));
 const RtkFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rtkfixedsolution_free(ptr, 1));
@@ -19803,6 +21761,9 @@ const SpaceWeatherFinalization = (typeof FinalizationRegistry === 'undefined')
 const SpaceWeatherDefaultsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spaceweatherdefaults_free(ptr, 1));
+const SpaceWeatherTableFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spaceweathertable_free(ptr, 1));
 const SpkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spk_free(ptr, 1));
@@ -19827,6 +21788,9 @@ const SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
 const TleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tle_free(ptr, 1));
+const TleFitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tlefit_free(ptr, 1));
 const TlePropagationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tlepropagation_free(ptr, 1));