@neilberkman/sidereon 0.10.0 → 0.11.0

package/pkg-node/sidereon.js

@@ -734,6 +734,25 @@ class BiasSet {
 if (Symbol.dispose) BiasSet.prototype[Symbol.dispose] = BiasSet.prototype.free;
 exports.BiasSet = BiasSet;
 
+/**
+ * Broadcast group-delay term selector.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
+ */
+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",
+});
+exports.BroadcastDelayTerm = BroadcastDelayTerm;
+
 /**
  * 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.
@@ -815,6 +834,22 @@ 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}
@@ -1015,6 +1050,46 @@ class BroadcastEvaluation {
 if (Symbol.dispose) BroadcastEvaluation.prototype[Symbol.dispose] = BroadcastEvaluation.prototype.free;
 exports.BroadcastEvaluation = BroadcastEvaluation;
 
+/**
+ * Per-signal broadcast group-delay terms retained from a NAV record.
+ */
+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;
+exports.BroadcastGroupDelaysJs = BroadcastGroupDelaysJs;
+
 /**
  * One GPS, Galileo, or BeiDou broadcast ephemeris record from RINEX NAV.
  */
@@ -1043,6 +1118,14 @@ 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}
@@ -1081,6 +1164,30 @@ 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}
@@ -1133,6 +1240,68 @@ class BroadcastRecordJs {
 if (Symbol.dispose) BroadcastRecordJs.prototype[Symbol.dispose] = BroadcastRecordJs.prototype.free;
 exports.BroadcastRecordJs = BroadcastRecordJs;
 
+/**
+ * Store-level broadcast ephemeris evaluation at a J2000 query epoch.
+ */
+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;
+exports.BroadcastStoreEvaluation = BroadcastStoreEvaluation;
+
 /**
  * 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}
@@ -2279,6 +2448,126 @@ class ClockSeries {
 if (Symbol.dispose) ClockSeries.prototype[Symbol.dispose] = ClockSeries.prototype.free;
 exports.ClockSeries = ClockSeries;
 
+/**
+ * CNAV/CNAV-2 fields with no legacy LNAV counterpart.
+ */
+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;
+exports.CnavParametersJs = CnavParametersJs;
+
+/**
+ * GPS/QZSS signal used for CNAV inter-signal correction accessors.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+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",
+});
+exports.CnavSignal = CnavSignal;
+
 /**
  * Collision-probability result and encounter-plane summary.
  */
@@ -2632,91 +2921,236 @@ if (Symbol.dispose) CorrelationResult.prototype[Symbol.dispose] = CorrelationRes
 exports.CorrelationResult = CorrelationResult;
 
 /**
- * A computed look-angle grid for a set of satellites and ground stations at one
- * epoch. Build with [`coverageLookAngles`].
+ * Propagated state plus covariance nodes.
  */
-class CoverageGrid {
+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;
+exports.CovarianceEphemeris = CovarianceEphemeris;
+
+/**
+ * Frame a 6x6 state covariance is expressed in.
+ * @enum {0 | 1}
+ */
+const CovarianceFrame = Object.freeze({
+    Inertial: 0, "0": "Inertial",
+    Rtn: 1, "1": "Rtn",
+});
+exports.CovarianceFrame = CovarianceFrame;
+
+/**
+ * Covariances returned by explicit STM transport.
+ */
+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;
+exports.CovarianceTransportResult = CovarianceTransportResult;
+
+/**
+ * A computed look-angle grid for a set of satellites and ground stations at one
+ * epoch. Build with [`coverageLookAngles`].
+ */
+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);
@@ -4034,6 +4468,42 @@ 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
@@ -4077,6 +4547,28 @@ 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).
@@ -4099,6 +4591,38 @@ 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;
 exports.GeoidGrid = GeoidGrid;
@@ -6638,78 +7162,347 @@ exports.NamedTle = NamedTle;
 
 /**
  * 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}
  */
 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",
 });
 exports.NavMessage = NavMessage;
 
 /**
- * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ * Streaming NMEA epoch accumulator.
  */
-class ObsEpoch {
-    static __wrap(ptr) {
-        const obj = Object.create(ObsEpoch.prototype);
-        obj.__wbg_ptr = ptr;
-        ObsEpochFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+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;
+exports.NmeaAccumulator = NmeaAccumulator;
+
+/**
+ * Parsed NMEA log.
+ */
+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;
+exports.NmeaParseResult = NmeaParseResult;
+
+/**
+ * Sans-IO NTRIP client state machine.
+ */
+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;
+exports.NtripClientMachine = NtripClientMachine;
+
+/**
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+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",
+});
+exports.NtripState = NtripState;
+
+/**
+ * @enum {0 | 1}
+ */
+const NtripVersion = Object.freeze({
+    Rev1: 0, "0": "Rev1",
+    Rev2: 1, "1": "Rev2",
+});
+exports.NtripVersion = NtripVersion;
+
+/**
+ * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ */
+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() {
@@ -8172,6 +8965,14 @@ 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}
@@ -8230,9 +9031,10 @@ 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]);
         }
@@ -10387,6 +11189,88 @@ class RinexClock {
 if (Symbol.dispose) RinexClock.prototype[Symbol.dispose] = RinexClock.prototype.free;
 exports.RinexClock = RinexClock;
 
+/**
+ * Navigation repair result.
+ */
+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];
+    }
+    /**
+     * @returns {BroadcastRecordJs[]}
+     */
+    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;
+    }
+    /**
+     * @returns {any}
+     */
+    get remaining() {
+        const ret = wasm.rinexnavrepair_remaining(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get repairedText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rinexnavrepair_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);
+        }
+    }
+}
+if (Symbol.dispose) RinexNavRepair.prototype[Symbol.dispose] = RinexNavRepair.prototype.free;
+exports.RinexNavRepair = RinexNavRepair;
+
 /**
  * A parsed RINEX 3/4 observation file.
  */
@@ -10532,6 +11416,145 @@ class RinexObs {
 if (Symbol.dispose) RinexObs.prototype[Symbol.dispose] = RinexObs.prototype.free;
 exports.RinexObs = RinexObs;
 
+/**
+ * Observation repair result.
+ */
+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;
+exports.RinexObsRepair = RinexObsRepair;
+
+/**
+ * Stateful MSM lock-time tracker for deriving RINEX LLI continuity bits.
+ */
+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;
+exports.RtcmLockTimeTracker = RtcmLockTimeTracker;
+
 /**
  * Validated fixed RTK baseline solution.
  */
@@ -11964,81 +12987,238 @@ class SpaceWeather {
     /**
      * @returns {number}
      */
-    get f107() {
-        const ret = wasm.spaceweather_f107(this.__wbg_ptr);
-        return ret;
+    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;
+exports.SpaceWeather = SpaceWeather;
+
+/**
+ * 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.
+ */
+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;
+exports.SpaceWeatherDefaults = SpaceWeatherDefaults;
+
+/**
+ * Parsed CelesTrak CSSI space-weather table.
+ */
+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 {any}
+     */
+    days() {
+        const ret = wasm.spaceweathertable_days(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get diagnostics() {
+        const ret = wasm.spaceweathertable_diagnostics(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    monthly() {
+        const ret = wasm.spaceweathertable_monthly(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * @returns {number}
      */
-    get f107a() {
-        const ret = wasm.spaceweather_f107a(this.__wbg_ptr);
-        return ret;
+    get monthlyCount() {
+        const ret = wasm.spaceweathertable_monthlyCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * @param {number | null} [f107]
-     * @param {number | null} [f107a]
-     * @param {number | null} [ap]
+     * @param {number} epoch_j2000_s
+     * @param {any} policy
+     * @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;
-exports.SpaceWeather = SpaceWeather;
-
-/**
- * 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.
- */
-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);
+    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;
-exports.SpaceWeatherDefaults = SpaceWeatherDefaults;
+if (Symbol.dispose) SpaceWeatherTable.prototype[Symbol.dispose] = SpaceWeatherTable.prototype.free;
+exports.SpaceWeatherTable = SpaceWeatherTable;
 
 /**
  * A parsed in-memory JPL/NAIF SPK kernel.
@@ -12585,6 +13765,22 @@ class SsrCorrectionStore {
 if (Symbol.dispose) SsrCorrectionStore.prototype[Symbol.dispose] = SsrCorrectionStore.prototype.free;
 exports.SsrCorrectionStore = SsrCorrectionStore;
 
+/**
+ * Source stream for engineering-unit SSR corrections.
+ * @enum {0 | 1}
+ */
+const SsrSource = Object.freeze({
+    /**
+     * RTCM SSR messages.
+     */
+    RtcmSsr: 0, "0": "RtcmSsr",
+    /**
+     * Galileo High Accuracy Service messages.
+     */
+    GalileoHas: 1, "1": "GalileoHas",
+});
+exports.SsrSource = SsrSource;
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -13017,6 +14213,96 @@ class Tle {
 if (Symbol.dispose) Tle.prototype[Symbol.dispose] = Tle.prototype.free;
 exports.Tle = Tle;
 
+/**
+ * Result of fitting a TLE to TEME samples.
+ */
+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;
+exports.TleFit = TleFit;
+
 /**
  * TEME states from a batched SGP4 propagation. Each array is flat row-major,
  * length `3 * epochCount`.
@@ -13773,6 +15059,17 @@ function cn0(eirp_dbw, fspl_db, receiver_gt_dbk, other_losses_db) {
 }
 exports.cn0 = cn0;
 
+/**
+ * Nominal GPS/QZSS CNAV URA meters for an ED/NED0 index.
+ * @param {number} index
+ * @returns {number | undefined}
+ */
+function cnavUraNominalM(index) {
+    const ret = wasm.cnavUraNominalM(index);
+    return ret[0] === 0 ? undefined : ret[1];
+}
+exports.cnavUraNominalM = cnavUraNominalM;
+
 /**
  * @param {any} coe
  * @param {RetrogradeFactor | null} [factor]
@@ -14124,6 +15421,27 @@ function decodeRtcmMessage(body) {
 }
 exports.decodeRtcmMessage = decodeRtcmMessage;
 
+/**
+ * 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}
+ */
+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]);
+}
+exports.decodeRtcmStream = decodeRtcmStream;
+
 /**
  * @param {Uint8Array} bytes
  * @param {string | null} [form]
@@ -14510,6 +15828,42 @@ function egm96Undulation(lat_rad, lon_rad) {
 }
 exports.egm96Undulation = egm96Undulation;
 
+/**
+ * Batch EGM96 undulation lookup for flat `[latDeg, lonDeg, ...]` pairs.
+ * @param {Float64Array} points_deg
+ * @returns {Float64Array}
+ */
+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;
+}
+exports.egm96UndulationsDeg = egm96UndulationsDeg;
+
+/**
+ * Batch EGM96 undulation lookup for flat `[latRad, lonRad, ...]` pairs.
+ * @param {Float64Array} points_rad
+ * @returns {Float64Array}
+ */
+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;
+}
+exports.egm96UndulationsRad = egm96UndulationsRad;
+
 /**
  * Effective isotropic radiated power, dBW.
  * @param {number} tx_power_dbm
@@ -14733,6 +16087,24 @@ function estimateDecay(drag, request) {
 }
 exports.estimateDecay = estimateDecay;
 
+/**
+ * Estimate decay using per-epoch values from a parsed space-weather table.
+ * @param {DragForce} drag
+ * @param {SpaceWeatherTable} table
+ * @param {any} request
+ * @returns {any}
+ */
+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]);
+}
+exports.estimateDecayWithSpaceWeather = estimateDecayWithSpaceWeather;
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -14992,6 +16364,21 @@ function fitReducedOrbitTle(tle, options) {
 }
 exports.fitReducedOrbitTle = fitReducedOrbitTle;
 
+/**
+ * Fit SGP4 mean elements and optional B* to TEME state samples.
+ * @param {any} samples
+ * @param {any} config
+ * @returns {TleFit}
+ */
+function fitTle(samples, config) {
+    const ret = wasm.fitTle(samples, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TleFit.__wrap(ret[0]);
+}
+exports.fitTle = fitTle;
+
 /**
  * Fix Melbourne-Wubbena wide-lane ambiguities over a dual-frequency RTK arc.
  *
@@ -15241,11 +16628,49 @@ exports.geodeticToEcef = geodeticToEcef;
  * @param {number} lon_rad
  * @returns {number}
  */
-function geoidUndulation(lat_rad, lon_rad) {
-    const ret = wasm.geoidUndulation(lat_rad, lon_rad);
-    return ret;
+function geoidUndulation(lat_rad, lon_rad) {
+    const ret = wasm.geoidUndulation(lat_rad, lon_rad);
+    return ret;
+}
+exports.geoidUndulation = geoidUndulation;
+
+/**
+ * Batch coarse built-in undulation lookup for flat `[latDeg, lonDeg, ...]`
+ * pairs.
+ * @param {Float64Array} points_deg
+ * @returns {Float64Array}
+ */
+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;
+}
+exports.geoidUndulationsDeg = geoidUndulationsDeg;
+
+/**
+ * Batch coarse built-in undulation lookup for flat `[latRad, lonRad, ...]`
+ * pairs.
+ * @param {Float64Array} points_rad
+ * @returns {Float64Array}
+ */
+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;
 }
-exports.geoidUndulation = geoidUndulation;
+exports.geoidUndulationsRad = geoidUndulationsRad;
 
 /**
  * Geometry-free phase combination `L_GF = L1 - L2`, metres.
@@ -16009,6 +17434,38 @@ function leastSquaresDropOne(request) {
 }
 exports.leastSquaresDropOne = leastSquaresDropOne;
 
+/**
+ * Lint RINEX navigation text.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+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]);
+}
+exports.lintRinexNav = lintRinexNav;
+
+/**
+ * Lint RINEX observation text.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+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]);
+}
+exports.lintRinexObs = lintRinexObs;
+
 /**
  * Decode LNAV subframes 1-3 back into engineering-unit parameters.
  *
@@ -16803,6 +18260,47 @@ function nequickGStecTecu(_eval) {
 }
 exports.nequickGStecTecu = nequickGStecTecu;
 
+/**
+ * Parse bytes and return grouped epoch snapshots directly.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+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]);
+}
+exports.nmeaEpochs = nmeaEpochs;
+
+/**
+ * Write a GGA sentence from a JS object.
+ * @param {any} request
+ * @returns {string}
+ */
+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);
+    }
+}
+exports.nmeaWriteGga = nmeaWriteGga;
+
 /**
  * Equal-variance noise amplification of the ionosphere-free combination.
  * @param {number} f1_hz
@@ -16849,6 +18347,22 @@ function normalCovariance(jacobian, m, n, variance_scale) {
 }
 exports.normalCovariance = normalCovariance;
 
+/**
+ * Build the NTRIP connection request bytes for a config object.
+ * @param {any} config
+ * @returns {Uint8Array}
+ */
+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;
+}
+exports.ntripRequestBytes = ntripRequestBytes;
+
 /**
  * Predict observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -16917,6 +18431,22 @@ function observationKindLabel(kind) {
 }
 exports.observationKindLabel = observationKindLabel;
 
+/**
+ * Aggregate observation QC for a parsed RINEX OBS product.
+ * @param {RinexObs} obs
+ * @param {any} options
+ * @returns {any}
+ */
+function observationQc(obs, options) {
+    _assertClass(obs, RinexObs);
+    const ret = wasm.observationQc(obs.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observationQc = observationQc;
+
 /**
  * Observe `"sun"` or `"moon"` from a geodetic station at a UTC unix microsecond epoch.
  * @param {any} station
@@ -17101,6 +18631,35 @@ function parseNavcen(html) {
 }
 exports.parseNavcen = parseNavcen;
 
+/**
+ * Parse NMEA sentences from bytes.
+ * @param {Uint8Array} bytes
+ * @returns {NmeaParseResult}
+ */
+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);
+}
+exports.parseNmea = parseNmea;
+
+/**
+ * Parse NTRIP sourcetable text from UTF-8 bytes.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+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]);
+}
+exports.parseNtripSourcetable = parseNtripSourcetable;
+
 /**
  * Parse CCSDS OEM KVN text. The KVN reader is forgiving: malformed ephemeris
  * lines are skipped and counted in `skippedStates`. Throws an `Error` on a
@@ -17352,6 +18911,54 @@ function parseRinexObs(bytes) {
 }
 exports.parseRinexObs = parseRinexObs;
 
+/**
+ * Parse either CSV or fixed-width TXT space-weather bytes.
+ * @param {Uint8Array} bytes
+ * @returns {SpaceWeatherTable}
+ */
+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]);
+}
+exports.parseSpaceWeather = parseSpaceWeather;
+
+/**
+ * Parse CelesTrak CSSI CSV space-weather text.
+ * @param {string} text
+ * @returns {SpaceWeatherTable}
+ */
+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]);
+}
+exports.parseSpaceWeatherCsv = parseSpaceWeatherCsv;
+
+/**
+ * Parse CelesTrak CSSI fixed-width TXT space-weather text.
+ * @param {string} text
+ * @returns {SpaceWeatherTable}
+ */
+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]);
+}
+exports.parseSpaceWeatherTxt = parseSpaceWeatherTxt;
+
 /**
  * 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
@@ -17647,6 +19254,20 @@ function propagateBatch(satellites, epochs_unix_us) {
 }
 exports.propagateBatch = propagateBatch;
 
+/**
+ * Propagate an ECI Cartesian state and 6x6 covariance to requested epochs.
+ * @param {any} request
+ * @returns {CovarianceEphemeris}
+ */
+function propagateCovariance(request) {
+    const ret = wasm.propagateCovariance(request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CovarianceEphemeris.__wrap(ret[0]);
+}
+exports.propagateCovariance = propagateCovariance;
+
 /**
  * @param {any} coe
  * @param {number} mu_km3_s2
@@ -17769,6 +19390,40 @@ function relativeState(chief, deputy) {
 }
 exports.relativeState = relativeState;
 
+/**
+ * Repair RINEX navigation text.
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {RinexNavRepair}
+ */
+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]);
+}
+exports.repairRinexNav = repairRinexNav;
+
+/**
+ * Repair RINEX observation text.
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {RinexObsRepair}
+ */
+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]);
+}
+exports.repairRinexObs = repairRinexObs;
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  * @param {bigint} prn
@@ -17862,6 +19517,39 @@ function rswRotation(position_km, velocity_km_s) {
 }
 exports.rswRotation = rswRotation;
 
+/**
+ * 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}
+ */
+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];
+}
+exports.rtcmDeriveLli = rtcmDeriveLli;
+
+/**
+ * RINEX LLI bit constants used by the RTCM MSM LLI helpers.
+ * @returns {any}
+ */
+function rtcmLliBits() {
+    const ret = wasm.rtcmLliBits();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.rtcmLliBits = rtcmLliBits;
+
 /**
  * Read the 12-bit RTCM message number from a message body.
  *
@@ -17881,6 +19569,62 @@ function rtcmMessageNumber(body) {
 }
 exports.rtcmMessageNumber = rtcmMessageNumber;
 
+/**
+ * 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}
+ */
+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]);
+}
+exports.rtcmMinimumLockTimeMs = rtcmMinimumLockTimeMs;
+
+/**
+ * Elapsed milliseconds between two raw MSM epoch-time fields.
+ * @param {string} system
+ * @param {number} previous_epoch_time
+ * @param {number} current_epoch_time
+ * @returns {number}
+ */
+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];
+}
+exports.rtcmMsmEpochDtMs = rtcmMsmEpochDtMs;
+
+/**
+ * RINEX 3 observation-code suffix for an MSM signal id, or `undefined` for
+ * reserved ids.
+ * @param {string} system
+ * @param {number} signal_id
+ * @returns {any}
+ */
+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]);
+}
+exports.rtcmMsmSignalRinexCode = rtcmMsmSignalRinexCode;
+
 /**
  * @param {Float64Array} position_km
  * @param {Float64Array} velocity_km_s
@@ -18840,6 +20584,25 @@ function ssrCorrectedState(broadcast, store, sat, t_j2000_s, fallback_to_broadca
 }
 exports.ssrCorrectedState = ssrCorrectedState;
 
+/**
+ * Stable lower-camel-case SSR source token.
+ * @param {SsrSource} source
+ * @returns {string}
+ */
+function ssrSourceLabel(source) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.ssrSourceLabel(source);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.ssrSourceLabel = ssrSourceLabel;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *
@@ -19145,6 +20908,24 @@ function toCsv(records, booleans) {
 }
 exports.toCsv = toCsv;
 
+/**
+ * Transport a 6x6 covariance through caller-supplied STM segments.
+ * @param {Float64Array} covariance
+ * @param {any} segments
+ * @param {any} options
+ * @returns {CovarianceTransportResult}
+ */
+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]);
+}
+exports.transportCovariance = transportCovariance;
+
 /**
  * Niell hydrostatic and wet mapping factors at an elevation.
  *
@@ -19522,6 +21303,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;
@@ -19854,9 +21639,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));
@@ -19884,6 +21675,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));
@@ -19896,6 +21690,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));
@@ -20043,6 +21843,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));
@@ -20148,9 +21957,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));
@@ -20211,6 +22029,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));
@@ -20235,6 +22056,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));