@neilberkman/sidereon 0.11.1 → 0.13.0

package/pkg-node/sidereon.js

@@ -884,6 +884,43 @@ class BroadcastEphemeris {
         const ret = wasm.broadcastephemeris_leapSeconds(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Query ECEF position and clock for parallel satellite and epoch arrays
+     * against this parsed broadcast ephemeris store.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 in GPST for GNSS broadcast records. The returned
+     * plain object has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.broadcastephemeris_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and clock for many satellites at one epoch against
+     * this parsed broadcast ephemeris store.
+     *
+     * `epochJ2000S` is seconds since J2000 in GPST. The returned object follows
+     * the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.broadcastephemeris_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Number of usable GPS, Galileo, and BeiDou records.
      * @returns {number}
@@ -3832,6 +3869,12 @@ class DragForce {
 if (Symbol.dispose) DragForce.prototype[Symbol.dispose] = DragForce.prototype.free;
 exports.DragForce = DragForce;
 
+/**
+ * A DTED terrain tile cache rooted at a directory of DTED Level 2 files.
+ *
+ * Heights are ORTHOMETRIC terrain elevations in meters. Point order is always
+ * longitude first, then latitude, both in degrees.
+ */
 class DtedTerrain {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -3844,6 +3887,30 @@ class DtedTerrain {
         wasm.__wbg_dtedterrain_free(ptr, 0);
     }
     /**
+     * Batch terrain heights in ORTHOMETRIC meters for longitude-first points.
+     *
+     * `points` is an array of `[longitudeDeg, latitudeDeg]` pairs or
+     * `{ longitudeDeg, latitudeDeg }` objects. `options.interpolation` is
+     * `"bilinear"`, `"nearest"`, or `"nearestPosting"`. The return value is
+     * index-aligned to `points`; each entry is `{ ok: true, heightM }` or
+     * `{ ok: false, error }`. Missing tiles evaluate to `0.0`.
+     * @param {any} points
+     * @param {any} options
+     * @returns {any}
+     */
+    heightBatch(points, options) {
+        const ret = wasm.dtedterrain_heightBatch(this.__wbg_ptr, points, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Terrain height in ORTHOMETRIC meters at `(longitudeDeg, latitudeDeg)`.
+     *
+     * Longitude and latitude are degrees. The lookup uses bilinear
+     * interpolation. Missing tiles evaluate to `0.0`, matching the core DTED
+     * fallback.
      * @param {number} longitude_deg
      * @param {number} latitude_deg
      * @returns {number}
@@ -3856,6 +3923,11 @@ class DtedTerrain {
         return ret[0];
     }
     /**
+     * Terrain height in ORTHOMETRIC meters at `(longitudeDeg, latitudeDeg)`.
+     *
+     * Longitude and latitude are degrees. `options.interpolation` is
+     * `"bilinear"`, `"nearest"`, or `"nearestPosting"`. Missing tiles evaluate
+     * to `0.0`, matching the core DTED fallback.
      * @param {number} longitude_deg
      * @param {number} latitude_deg
      * @param {any} options
@@ -3869,6 +3941,10 @@ class DtedTerrain {
         return ret[0];
     }
     /**
+     * Create a DTED terrain reader rooted at `root`.
+     *
+     * The root may contain tile files directly or the nested block layout the
+     * core reader recognizes. Height results are ORTHOMETRIC meters.
      * @param {string} root
      */
     constructor(root) {
@@ -3883,6 +3959,101 @@ class DtedTerrain {
 if (Symbol.dispose) DtedTerrain.prototype[Symbol.dispose] = DtedTerrain.prototype.free;
 exports.DtedTerrain = DtedTerrain;
 
+/**
+ * Loaded EGM96 15-arcminute geoid grid for explicit terrain datum conversion.
+ */
+class Egm96FifteenMinuteGeoid {
+    static __wrap(ptr) {
+        const obj = Object.create(Egm96FifteenMinuteGeoid.prototype);
+        obj.__wbg_ptr = ptr;
+        Egm96FifteenMinuteGeoidFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Egm96FifteenMinuteGeoidFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_egm96fifteenminutegeoid_free(ptr, 0);
+    }
+    /**
+     * Load `WW15MGH.DAC` bytes as an EGM96 15-arcminute geoid grid.
+     * @param {Uint8Array} bytes
+     * @returns {Egm96FifteenMinuteGeoid}
+     */
+    static fromWw15mghDacBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.egm96fifteenminutegeoid_fromWw15mghDacBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Egm96FifteenMinuteGeoid.__wrap(ret[0]);
+    }
+    /**
+     * Read and load `WW15MGH.DAC` from disk. A missing file throws a typed
+     * `MissingEgm96Dac` error with `path` and `remediation` fields.
+     * @param {string} path
+     * @returns {Egm96FifteenMinuteGeoid}
+     */
+    static fromWw15mghDacPath(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.egm96fifteenminutegeoid_fromWw15mghDacPath(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Egm96FifteenMinuteGeoid.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) Egm96FifteenMinuteGeoid.prototype[Symbol.dispose] = Egm96FifteenMinuteGeoid.prototype.free;
+exports.Egm96FifteenMinuteGeoid = Egm96FifteenMinuteGeoid;
+
+/**
+ * Ellipsoidal height `h` in metres above the WGS84 reference ellipsoid.
+ */
+class EllipsoidalHeightM {
+    static __wrap(ptr) {
+        const obj = Object.create(EllipsoidalHeightM.prototype);
+        obj.__wbg_ptr = ptr;
+        EllipsoidalHeightMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EllipsoidalHeightMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ellipsoidalheightm_free(ptr, 0);
+    }
+    /**
+     * Build an ellipsoidal height `h` in metres.
+     * @param {number} value_m
+     */
+    constructor(value_m) {
+        const ret = wasm.ellipsoidalheightm_new(value_m);
+        this.__wbg_ptr = ret;
+        EllipsoidalHeightMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Ellipsoidal height `h`, metres above the WGS84 reference ellipsoid.
+     * @returns {number}
+     */
+    get valueM() {
+        const ret = wasm.ellipsoidalheightm_valueM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) EllipsoidalHeightM.prototype[Symbol.dispose] = EllipsoidalHeightM.prototype.free;
+exports.EllipsoidalHeightM = EllipsoidalHeightM;
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -5518,6 +5689,24 @@ class Ionex {
         const ret = wasm.ionex_baseRadiusKm(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Signed latitude grid step, degrees. Standard IONEX grids are
+     * north-to-south, so this value is usually negative.
+     * @returns {number}
+     */
+    get dlatDeg() {
+        const ret = wasm.ionex_dlatDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Signed longitude grid step, degrees. Standard IONEX grids are
+     * west-to-east, so this value is usually positive.
+     * @returns {number}
+     */
+    get dlonDeg() {
+        const ret = wasm.ionex_dlonDeg(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * The IONEX `EXPONENT` header field; the TEC scale is `10^exponent`.
      * @returns {number}
@@ -5591,6 +5780,36 @@ class Ionex {
         }
         return ret[0];
     }
+    /**
+     * Extract the full IONEX vertical-TEC grids as plain sample data.
+     *
+     * Epochs are integer seconds since J2000. Latitude and longitude nodes and
+     * grid steps are degrees. TEC and RMS maps are TECU and indexed
+     * `[map][iLat][iLon]`. The shell height and base radius are kilometers.
+     * @returns {any}
+     */
+    tecGridSamples() {
+        const ret = wasm.ionex_tecGridSamples(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Extract one IONEX vertical-TEC sample per grid node.
+     *
+     * Each sample is `{ epochJ2000S, latDeg, lonDeg, vtecTecu, rmsTecu }`.
+     * Epochs are integer seconds since J2000, coordinates are degrees, and TEC
+     * and RMS values are TECU.
+     * @returns {any}
+     */
+    tecSamples() {
+        const ret = wasm.ionex_tecSamples(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Serialize to standard IONEX text. Deterministic: the same product always
      * produces byte-identical text, and re-parsing the output yields an equal
@@ -6910,119 +7129,369 @@ if (Symbol.dispose) MappingFactors.prototype[Symbol.dispose] = MappingFactors.pr
 exports.MappingFactors = MappingFactors;
 
 /**
- * One refined Moon elevation threshold crossing (moonrise / moonset).
+ * In-memory reader for memory-mappable terrain store bytes.
+ *
+ * Query results are orthometric terrain heights `H` in metres. Use the
+ * ellipsoidal methods only when a geoid model is deliberately selected.
  */
-class MoonElevationCrossing {
+class MmapTerrain {
     static __wrap(ptr) {
-        const obj = Object.create(MoonElevationCrossing.prototype);
+        const obj = Object.create(MmapTerrain.prototype);
         obj.__wbg_ptr = ptr;
-        MoonElevationCrossingFinalization.register(obj, obj.__wbg_ptr, obj);
+        MmapTerrainFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MoonElevationCrossingFinalization.unregister(this);
+        MmapTerrainFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_moonelevationcrossing_free(ptr, 0);
+        wasm.__wbg_mmapterrain_free(ptr, 0);
     }
     /**
-     * Topocentric Moon elevation at the refined instant, degrees.
-     * @returns {number}
+     * FNV-1a checksum of the full terrain store byte span.
+     * @returns {bigint}
      */
-    get elevationDeg() {
-        const ret = wasm.moonelevationcrossing_elevationDeg(this.__wbg_ptr);
-        return ret;
+    checksum64() {
+        const ret = wasm.mmapterrain_checksum64(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * Crossing direction: `"rising"` (moonrise) or `"setting"` (moonset).
-     * @returns {string}
+     * Ellipsoidal height `h = H + N` in metres at `(longitudeDeg, latitudeDeg)`
+     * using the embedded EGM96 1-degree geoid grid.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @returns {EllipsoidalHeightM}
      */
-    get kind() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.moonelevationcrossing_kind(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);
+    ellipsoidalHeightM(longitude_deg, latitude_deg) {
+        const ret = wasm.mmapterrain_ellipsoidalHeightM(this.__wbg_ptr, longitude_deg, latitude_deg);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return EllipsoidalHeightM.__wrap(ret[0]);
     }
     /**
-     * Refined crossing instant, unix microseconds.
-     * @returns {bigint}
+     * Ellipsoidal height `h = H + N` in metres using an explicit geoid model.
+     *
+     * The terrain lookup input order is `(longitudeDeg, latitudeDeg)`. Choosing
+     * the EGM96 15-arcminute model requires a loaded `WW15MGH.DAC` grid and
+     * does not fall back to the embedded 1-degree grid.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @param {any} options
+     * @param {TerrainGeoidModel} geoid
+     * @returns {EllipsoidalHeightM}
      */
-    get timeUnixUs() {
-        const ret = wasm.moonelevationcrossing_timeUnixUs(this.__wbg_ptr);
-        return ret;
+    ellipsoidalHeightMWithModel(longitude_deg, latitude_deg, options, geoid) {
+        _assertClass(geoid, TerrainGeoidModel);
+        const ret = wasm.mmapterrain_ellipsoidalHeightMWithModel(this.__wbg_ptr, longitude_deg, latitude_deg, options, geoid.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EllipsoidalHeightM.__wrap(ret[0]);
     }
-}
-if (Symbol.dispose) MoonElevationCrossing.prototype[Symbol.dispose] = MoonElevationCrossing.prototype.free;
-exports.MoonElevationCrossing = MoonElevationCrossing;
-
-/**
- * One refined Moon meridian transit (culmination).
- */
-class MoonTransit {
-    static __wrap(ptr) {
-        const obj = Object.create(MoonTransit.prototype);
-        obj.__wbg_ptr = ptr;
-        MoonTransitFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    /**
+     * Ellipsoidal height `h = H + N` in metres using embedded EGM96 1-degree
+     * geoid conversion and explicit terrain lookup options.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @param {any} options
+     * @returns {EllipsoidalHeightM}
+     */
+    ellipsoidalHeightMWithOptions(longitude_deg, latitude_deg, options) {
+        const ret = wasm.mmapterrain_ellipsoidalHeightMWithOptions(this.__wbg_ptr, longitude_deg, latitude_deg, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EllipsoidalHeightM.__wrap(ret[0]);
     }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        MoonTransitFinalization.unregister(this);
-        return ptr;
+    /**
+     * Parse terrain store bytes from a `Uint8Array`.
+     * @param {Uint8Array} bytes
+     * @returns {MmapTerrain}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmapterrain_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MmapTerrain.__wrap(ret[0]);
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_moontransit_free(ptr, 0);
+    /**
+     * Read a terrain store file from host I/O and parse it into memory.
+     *
+     * Browser runtimes should use [`MmapTerrain.fromBytes`] with fetched bytes.
+     * @param {string} path
+     * @returns {MmapTerrain}
+     */
+    static fromPath(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmapterrain_fromPath(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MmapTerrain.__wrap(ret[0]);
     }
     /**
-     * Topocentric Moon elevation at the refined instant, degrees.
-     * @returns {number}
+     * Parse terrain store bytes from an owned `Uint8Array` copy.
+     * @param {Uint8Array} bytes
+     * @returns {MmapTerrain}
      */
-    get elevationDeg() {
-        const ret = wasm.moontransit_elevationDeg(this.__wbg_ptr);
-        return ret;
+    static fromVec(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmapterrain_fromVec(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MmapTerrain.__wrap(ret[0]);
     }
     /**
-     * Culmination kind: `"upper"` (due south, highest) or `"lower"` (due north,
-     * lowest).
-     * @returns {string}
+     * Batch ORTHOMETRIC terrain heights for longitude-first points.
+     *
+     * `points` is an array of `[longitudeDeg, latitudeDeg]` pairs or
+     * `{ longitudeDeg, latitudeDeg }` objects. Each entry is
+     * `{ ok: true, heightM }` or `{ ok: false, error }`.
+     * @param {any} points
+     * @param {any} options
+     * @returns {any}
      */
-    get kind() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.moontransit_kind(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);
+    heightBatch(points, options) {
+        const ret = wasm.mmapterrain_heightBatch(this.__wbg_ptr, points, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Refined culmination instant, unix microseconds.
-     * @returns {bigint}
+     * Terrain height in ORTHOMETRIC metres at `(longitudeDeg, latitudeDeg)`.
+     *
+     * Longitude and latitude are degrees. The lookup uses bilinear
+     * interpolation. Missing tiles evaluate to `0.0`.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @returns {number}
      */
-    get timeUnixUs() {
-        const ret = wasm.moontransit_timeUnixUs(this.__wbg_ptr);
-        return ret;
+    heightM(longitude_deg, latitude_deg) {
+        const ret = wasm.mmapterrain_heightM(this.__wbg_ptr, longitude_deg, latitude_deg);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
-}
-if (Symbol.dispose) MoonTransit.prototype[Symbol.dispose] = MoonTransit.prototype.free;
-exports.MoonTransit = MoonTransit;
-
-/**
+    /**
+     * Terrain height in ORTHOMETRIC metres at `(longitudeDeg, latitudeDeg)`.
+     *
+     * `options.interpolation` is `"bilinear"`, `"nearest"`, or
+     * `"nearestPosting"`.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @param {any} options
+     * @returns {number}
+     */
+    heightMWithOptions(longitude_deg, latitude_deg, options) {
+        const ret = wasm.mmapterrain_heightMWithOptions(this.__wbg_ptr, longitude_deg, latitude_deg, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Batch typed ORTHOMETRIC terrain heights for longitude-first points.
+     *
+     * Each entry is `{ ok: true, orthometricHeightM: { valueM } }` or
+     * `{ ok: false, error }`.
+     * @param {any} points
+     * @param {any} options
+     * @returns {any}
+     */
+    orthometricHeightBatch(points, options) {
+        const ret = wasm.mmapterrain_orthometricHeightBatch(this.__wbg_ptr, points, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @returns {OrthometricHeightM}
+     */
+    orthometricHeightM(longitude_deg, latitude_deg) {
+        const ret = wasm.mmapterrain_orthometricHeightM(this.__wbg_ptr, longitude_deg, latitude_deg);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OrthometricHeightM.__wrap(ret[0]);
+    }
+    /**
+     * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`
+     * with explicit lookup options.
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @param {any} options
+     * @returns {OrthometricHeightM}
+     */
+    orthometricHeightMWithOptions(longitude_deg, latitude_deg, options) {
+        const ret = wasm.mmapterrain_orthometricHeightMWithOptions(this.__wbg_ptr, longitude_deg, latitude_deg, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OrthometricHeightM.__wrap(ret[0]);
+    }
+    /**
+     * Parsed tile index records in store order.
+     * @returns {TerrainStoreTileIndex[]}
+     */
+    tileIndex() {
+        const ret = wasm.mmapterrain_tileIndex(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Canonical store bytes for this parsed terrain store.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.mmapterrain_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * File-level vertical datum for the store's orthometric posting payloads.
+     * @returns {VerticalDatum}
+     */
+    get verticalDatum() {
+        const ret = wasm.mmapterrain_verticalDatum(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MmapTerrain.prototype[Symbol.dispose] = MmapTerrain.prototype.free;
+exports.MmapTerrain = MmapTerrain;
+
+/**
+ * One refined Moon elevation threshold crossing (moonrise / moonset).
+ */
+class MoonElevationCrossing {
+    static __wrap(ptr) {
+        const obj = Object.create(MoonElevationCrossing.prototype);
+        obj.__wbg_ptr = ptr;
+        MoonElevationCrossingFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MoonElevationCrossingFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_moonelevationcrossing_free(ptr, 0);
+    }
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     * @returns {number}
+     */
+    get elevationDeg() {
+        const ret = wasm.moonelevationcrossing_elevationDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Crossing direction: `"rising"` (moonrise) or `"setting"` (moonset).
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.moonelevationcrossing_kind(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);
+        }
+    }
+    /**
+     * Refined crossing instant, unix microseconds.
+     * @returns {bigint}
+     */
+    get timeUnixUs() {
+        const ret = wasm.moonelevationcrossing_timeUnixUs(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MoonElevationCrossing.prototype[Symbol.dispose] = MoonElevationCrossing.prototype.free;
+exports.MoonElevationCrossing = MoonElevationCrossing;
+
+/**
+ * One refined Moon meridian transit (culmination).
+ */
+class MoonTransit {
+    static __wrap(ptr) {
+        const obj = Object.create(MoonTransit.prototype);
+        obj.__wbg_ptr = ptr;
+        MoonTransitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MoonTransitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_moontransit_free(ptr, 0);
+    }
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     * @returns {number}
+     */
+    get elevationDeg() {
+        const ret = wasm.moontransit_elevationDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Culmination kind: `"upper"` (due south, highest) or `"lower"` (due north,
+     * lowest).
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.moontransit_kind(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);
+        }
+    }
+    /**
+     * Refined culmination instant, unix microseconds.
+     * @returns {bigint}
+     */
+    get timeUnixUs() {
+        const ret = wasm.moontransit_timeUnixUs(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MoonTransit.prototype[Symbol.dispose] = MoonTransit.prototype.free;
+exports.MoonTransit = MoonTransit;
+
+/**
  * One solved moving-baseline epoch.
  */
 class MovingBaselineSolution {
@@ -10049,6 +10518,81 @@ class OpmState {
 if (Symbol.dispose) OpmState.prototype[Symbol.dispose] = OpmState.prototype.free;
 exports.OpmState = OpmState;
 
+/**
+ * Orthometric terrain height `H` in metres above the EGM96 mean sea level
+ * geoid.
+ */
+class OrthometricHeightM {
+    static __wrap(ptr) {
+        const obj = Object.create(OrthometricHeightM.prototype);
+        obj.__wbg_ptr = ptr;
+        OrthometricHeightMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrthometricHeightMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orthometricheightm_free(ptr, 0);
+    }
+    /**
+     * Build an orthometric height `H` in metres.
+     * @param {number} value_m
+     */
+    constructor(value_m) {
+        const ret = wasm.orthometricheightm_new(value_m);
+        this.__wbg_ptr = ret;
+        OrthometricHeightMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Convert to ellipsoidal height `h = H + N` using degree inputs in geoid
+     * order `(latitudeDeg, longitudeDeg)` and an explicit geoid model.
+     * @param {number} latitude_deg
+     * @param {number} longitude_deg
+     * @param {TerrainGeoidModel} geoid
+     * @returns {EllipsoidalHeightM}
+     */
+    toEllipsoidalHeightDeg(latitude_deg, longitude_deg, geoid) {
+        _assertClass(geoid, TerrainGeoidModel);
+        const ret = wasm.orthometricheightm_toEllipsoidalHeightDeg(this.__wbg_ptr, latitude_deg, longitude_deg, geoid.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EllipsoidalHeightM.__wrap(ret[0]);
+    }
+    /**
+     * Convert to ellipsoidal height `h = H + N` using radian inputs in geoid
+     * order `(latitudeRad, longitudeRad)` and an explicit geoid model.
+     * @param {number} latitude_rad
+     * @param {number} longitude_rad
+     * @param {TerrainGeoidModel} geoid
+     * @returns {EllipsoidalHeightM}
+     */
+    toEllipsoidalHeightRad(latitude_rad, longitude_rad, geoid) {
+        _assertClass(geoid, TerrainGeoidModel);
+        const ret = wasm.orthometricheightm_toEllipsoidalHeightRad(this.__wbg_ptr, latitude_rad, longitude_rad, geoid.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EllipsoidalHeightM.__wrap(ret[0]);
+    }
+    /**
+     * Orthometric height `H`, metres above the EGM96 mean sea level geoid.
+     * @returns {number}
+     */
+    get valueM() {
+        const ret = wasm.orthometricheightm_valueM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) OrthometricHeightM.prototype[Symbol.dispose] = OrthometricHeightM.prototype.free;
+exports.OrthometricHeightM = OrthometricHeightM;
+
 /**
  * The result of [`parseTleFile`]: the satellites that parsed, plus a count of
  * complete records that were skipped because SGP4 initialization failed.
@@ -10543,52 +11087,244 @@ if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolutio
 exports.PppFloatSolution = PppFloatSolution;
 
 /**
- * A precise-ephemeris source built from samples rather than parsed SP3 text.
+ * A reusable precise-ephemeris interpolant with cached per-satellite nodes.
  *
- * Implements the same `ObservableEphemerisSource` contract as a parsed [`Sp3`]
- * product and shares its interpolation substrate, so [`predictRanges`] accepts
- * either handle. Build one with [`preciseEphemerisSamplesFromSamples`].
- */
-class PreciseEphemerisSampleSource {
+ * Build this handle once from a parsed [`Sp3`] product, raw precise samples, or
+ * a [`PreciseEphemerisSampleSource`], then reuse it for many state or range
+ * queries. The handle delegates to
+ * `sidereon_core::ephemeris::PreciseEphemerisInterpolant`; ECEF positions are
+ * metres, clocks are seconds, and query epochs are seconds since J2000 in the
+ * source time scale.
+ */
+class PreciseEphemerisInterpolant {
     static __wrap(ptr) {
-        const obj = Object.create(PreciseEphemerisSampleSource.prototype);
+        const obj = Object.create(PreciseEphemerisInterpolant.prototype);
         obj.__wbg_ptr = ptr;
-        PreciseEphemerisSampleSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+        PreciseEphemerisInterpolantFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PreciseEphemerisSampleSourceFinalization.unregister(this);
+        PreciseEphemerisInterpolantFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_preciseephemerissamplesource_free(ptr, 0);
+        wasm.__wbg_preciseephemerisinterpolant_free(ptr, 0);
     }
     /**
-     * Predict geometric ranges for many requests in one call. See the shared
-     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
-     * this is the sample-source entry point.
-     * @param {any} requests
-     * @param {any} options
+     * Build a cached interpolant from an existing sample-backed precise source.
+     * @param {PreciseEphemerisSampleSource} source
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromPreciseEphemerisSamples(source) {
+        _assertClass(source, PreciseEphemerisSampleSource);
+        const ret = wasm.preciseephemerisinterpolant_fromPreciseEphemerisSamples(source.__wbg_ptr);
+        return PreciseEphemerisInterpolant.__wrap(ret);
+    }
+    /**
+     * Build a cached interpolant directly from precise samples.
+     *
+     * `samples` is the same array accepted by
+     * [`preciseEphemerisSamplesFromSamples`]: each item has `{ sat, epoch,
+     * positionEcefM, clockS?, clockEvent? }`, with epochs in seconds since
+     * J2000 and positions in ECEF metres. Throws a `TypeError` for malformed
+     * JS input and a `RangeError` for sample validation failures.
+     * @param {any} samples
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromSamples(samples) {
+        const ret = wasm.preciseephemerisinterpolant_fromSamples(samples);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PreciseEphemerisInterpolant.__wrap(ret[0]);
+    }
+    /**
+     * Build a cached interpolant from a parsed SP3 precise product.
+     *
+     * Nodes are copied from the product's native SP3 records. Query epochs are
+     * seconds since J2000 in the SP3 product time scale.
+     * @param {Sp3} sp3
+     * @returns {PreciseEphemerisInterpolant}
+     */
+    static fromSp3(sp3) {
+        _assertClass(sp3, Sp3);
+        const ret = wasm.preciseephemerisinterpolant_fromSp3(sp3.__wbg_ptr);
+        return PreciseEphemerisInterpolant.__wrap(ret);
+    }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays using this cached interpolant.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 on this handle's time scale. The returned plain
+     * object has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
      * @returns {any}
      */
-    predictRanges(requests, options) {
-        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.preciseephemerisinterpolant_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
-     * @returns {string[]}
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * using this cached interpolant.
+     *
+     * `epochJ2000S` is seconds since J2000 on this handle's time scale. The
+     * returned object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
      */
-    get satellites() {
-        const ret = wasm.preciseephemerissamplesource_satellites(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.preciseephemerisinterpolant_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Predict geometric ranges for many `(satellite, receiver, epoch)`
+     * requests using this cached interpolant.
+     *
+     * `requests` is an array of `{ sat, receiverEcefM, tRxJ2000S }` objects.
+     * Positions are ECEF metres and epochs are seconds since J2000 on this
+     * handle's time scale. The output matches [`Sp3.predictRanges`].
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerisinterpolant_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Satellite tokens this handle can interpolate, ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerisinterpolant_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Source time-scale abbreviation used by this handle's J2000-second axis,
+     * such as `"GPST"`.
+     * @returns {string}
+     */
+    get timeScale() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preciseephemerisinterpolant_timeScale(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) PreciseEphemerisInterpolant.prototype[Symbol.dispose] = PreciseEphemerisInterpolant.prototype.free;
+exports.PreciseEphemerisInterpolant = PreciseEphemerisInterpolant;
+
+/**
+ * A precise-ephemeris source built from samples rather than parsed SP3 text.
+ *
+ * Implements the same `ObservableEphemerisSource` contract as a parsed [`Sp3`]
+ * product and shares its interpolation substrate, so [`predictRanges`] accepts
+ * either handle. Build one with [`preciseEphemerisSamplesFromSamples`].
+ */
+class PreciseEphemerisSampleSource {
+    static __wrap(ptr) {
+        const obj = Object.create(PreciseEphemerisSampleSource.prototype);
+        obj.__wbg_ptr = ptr;
+        PreciseEphemerisSampleSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreciseEphemerisSampleSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_preciseephemerissamplesource_free(ptr, 0);
+    }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays against this sample-backed precise source.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 on the source time scale. The returned plain object
+     * has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays. Failed elements use the core missing-position
+     * sentinel and carry the scalar engine error in `elementResults[i].error`.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.preciseephemerissamplesource_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * against this sample-backed precise source.
+     *
+     * `epochJ2000S` is seconds since J2000 on the source time scale. The
+     * returned plain object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.preciseephemerissamplesource_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Predict geometric ranges for many requests in one call. See the shared
+     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
+     * this is the sample-source entry point.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerissamplesource_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
 }
@@ -12050,6 +12786,12 @@ class SatelliteVector {
 if (Symbol.dispose) SatelliteVector.prototype[Symbol.dispose] = SatelliteVector.prototype.free;
 exports.SatelliteVector = SatelliteVector;
 
+/**
+ * Mutable SBAS correction store.
+ *
+ * Ingest raw SBAS messages with a source GEO and GNSS time, then query decoded
+ * fast, long-term, ionospheric, and GEO navigation correction records.
+ */
 class SbasCorrectionStore {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -12062,6 +12804,49 @@ class SbasCorrectionStore {
         wasm.__wbg_sbascorrectionstore_free(ptr, 0);
     }
     /**
+     * Fast pseudorange correction for `(geo, sat)`, or `null`.
+     *
+     * `prcM` is meters, `rrcMS` is meters per second, and `tOfJ2000S` is
+     * seconds since J2000.
+     * @param {string} geo
+     * @param {string} sat
+     * @returns {any}
+     */
+    fastCorrection(geo, sat) {
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_fastCorrection(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * SBAS GEO navigation state for `geo`, or `null`.
+     *
+     * Positions are ECEF meters, velocities are ECEF meters per second,
+     * accelerations are ECEF meters per second squared, clock fields are
+     * seconds and seconds per second, and `t0J2000S` is seconds since J2000.
+     * @param {string} geo
+     * @returns {any}
+     */
+    geoNavState(geo) {
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_geoNavState(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Ingest one decoded SBAS message into the correction store.
+     *
+     * `geo` is the SBAS source satellite token such as `"S29"`. `week` and
+     * `towS` are in the selected GNSS time scale. `form` is `"framed250"` or
+     * `"body226"`.
      * @param {Uint8Array} bytes
      * @param {string | null | undefined} form
      * @param {string} geo
@@ -12084,6 +12869,27 @@ class SbasCorrectionStore {
         }
     }
     /**
+     * SBAS ionospheric grid for `geo`, or `null`.
+     *
+     * Grid point latitudes and longitudes are degrees, vertical delays are
+     * meters, and GIVE variances are square meters when present.
+     * @param {string} geo
+     * @returns {any}
+     */
+    ionoGrid(geo) {
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_ionoGrid(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * SBAS ionospheric slant delay in meters, or `null`.
+     *
+     * Receiver latitude, longitude, elevation, and azimuth are radians.
+     * `frequencyHz` is the carrier frequency for the reported group delay.
      * @param {string} geo
      * @param {number} receiver_lat_rad
      * @param {number} receiver_lon_rad
@@ -12102,6 +12908,30 @@ class SbasCorrectionStore {
         }
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Long-term orbit and clock correction for `(geo, sat)`, or `null`.
+     *
+     * Position deltas are ECEF meters, rates are ECEF meters per second, clock
+     * deltas are seconds and seconds per second, and `t0J2000S` is seconds
+     * since J2000.
+     * @param {string} geo
+     * @param {string} sat
+     * @returns {any}
+     */
+    longTermCorrection(geo, sat) {
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_longTermCorrection(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create an empty SBAS correction store.
+     */
     constructor() {
         const ret = wasm.sbascorrectionstore_new();
         this.__wbg_ptr = ret;
@@ -12109,6 +12939,10 @@ class SbasCorrectionStore {
         return this;
     }
     /**
+     * Ready SBAS GEO source satellites at `tJ2000S`.
+     *
+     * The time is seconds since J2000. Returned tokens are strings such as
+     * `"S29"`, sorted by most recent update first.
      * @param {number} t_j2000_s
      * @returns {string[]}
      */
@@ -12118,6 +12952,24 @@ class SbasCorrectionStore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Allow or disallow partial SBAS corrections when building corrected
+     * ephemeris states.
+     * @param {boolean} yes
+     */
+    setAllowPartial(yes) {
+        wasm.sbascorrectionstore_setAllowPartial(this.__wbg_ptr, yes);
+    }
+    /**
+     * Set the maximum staleness for fresh SBAS corrections, in seconds.
+     * @param {number} seconds
+     */
+    setStalenessSeconds(seconds) {
+        const ret = wasm.sbascorrectionstore_setStalenessSeconds(this.__wbg_ptr, seconds);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) SbasCorrectionStore.prototype[Symbol.dispose] = SbasCorrectionStore.prototype.free;
 exports.SbasCorrectionStore = SbasCorrectionStore;
@@ -12519,6 +13371,44 @@ class Sp3 {
         }
         return Sp3Interpolation.__wrap(ret[0]);
     }
+    /**
+     * Query ECEF position and optional clock for parallel satellite and epoch
+     * arrays against this parsed SP3 product.
+     *
+     * `satellites[i]` is evaluated at `epochsJ2000S[i]`, where epochs are
+     * seconds since J2000 in the product time scale. The returned plain object
+     * has aligned `positionsEcefM`, `clocksS`, `statuses`, and
+     * `elementResults` arrays. Failed elements use the core missing-position
+     * sentinel and carry the scalar engine error in `elementResults[i].error`.
+     * @param {any} satellites
+     * @param {any} epochs_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtJ2000S(satellites, epochs_j2000_s) {
+        const ret = wasm.sp3_observableStatesAtJ2000S(this.__wbg_ptr, satellites, epochs_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Query ECEF position and optional clock for many satellites at one epoch
+     * against this parsed SP3 product.
+     *
+     * `epochJ2000S` is seconds since J2000 in the product time scale. The
+     * returned object follows the same contract as
+     * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
+     * @param {any} satellites
+     * @param {number} epoch_j2000_s
+     * @returns {any}
+     */
+    observableStatesAtSharedJ2000S(satellites, epoch_j2000_s) {
+        const ret = wasm.sp3_observableStatesAtSharedJ2000S(this.__wbg_ptr, satellites, epoch_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -14073,100 +14963,77 @@ if (Symbol.dispose) SunMoon.prototype[Symbol.dispose] = SunMoon.prototype.free;
 exports.SunMoon = SunMoon;
 
 /**
- * A named time scale. The JS value matches the variant order below.
- * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
+ * Terrain datum conversion and optional geoid-grid loading error variants.
+ * @enum {0 | 1 | 2 | 3}
  */
-const TimeScale = Object.freeze({
-    /**
-     * Coordinated Universal Time.
-     */
-    Utc: 0, "0": "Utc",
-    /**
-     * International Atomic Time.
-     */
-    Tai: 1, "1": "Tai",
-    /**
-     * Terrestrial Time.
-     */
-    Tt: 2, "2": "Tt",
-    /**
-     * Barycentric Dynamical Time.
-     */
-    Tdb: 3, "3": "Tdb",
-    /**
-     * GPS time.
-     */
-    Gpst: 4, "4": "Gpst",
+const TerrainDatumError = Object.freeze({
     /**
-     * Galileo System Time.
+     * Terrain lookup failed before datum conversion.
      */
-    Gst: 5, "5": "Gst",
+    Terrain: 0, "0": "Terrain",
     /**
-     * BeiDou Time.
+     * A geoid grid could not be parsed.
      */
-    Bdt: 6, "6": "Bdt",
+    Geoid: 1, "1": "Geoid",
     /**
-     * GLONASS system time (UTC(SU)-based, leap-second carrying).
+     * Reading a geoid grid failed for a reason other than absence.
      */
-    Glonasst: 7, "7": "Glonasst",
+    Io: 2, "2": "Io",
     /**
-     * QZSS system time (steered to GPST).
+     * The EGM96 15-arcminute `WW15MGH.DAC` grid was requested but is absent.
      */
-    Qzsst: 8, "8": "Qzsst",
+    MissingEgm96Dac: 3, "3": "MissingEgm96Dac",
 });
-exports.TimeScale = TimeScale;
+exports.TerrainDatumError = TerrainDatumError;
 
 /**
- * A parsed two-line element set with an initialized SGP4 satellite.
+ * Geoid model used to convert terrain orthometric height `H` to ellipsoidal
+ * height `h`.
  */
-class Tle {
+class TerrainGeoidModel {
     static __wrap(ptr) {
-        const obj = Object.create(Tle.prototype);
+        const obj = Object.create(TerrainGeoidModel.prototype);
         obj.__wbg_ptr = ptr;
-        TleFinalization.register(obj, obj.__wbg_ptr, obj);
+        TerrainGeoidModelFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof Tle)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TleFinalization.unregister(this);
+        TerrainGeoidModelFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tle_free(ptr, 0);
+        wasm.__wbg_terraingeoidmodel_free(ptr, 0);
     }
     /**
-     * Argument of perigee, degrees.
-     * @returns {number}
+     * Use a caller-supplied EGM96 15-arcminute geoid grid for `h = H + N`.
+     * @param {Egm96FifteenMinuteGeoid} geoid
+     * @returns {TerrainGeoidModel}
      */
-    get argPerigeeDeg() {
-        const ret = wasm.tle_argPerigeeDeg(this.__wbg_ptr);
-        return ret;
+    static egm96FifteenMinute(geoid) {
+        _assertClass(geoid, Egm96FifteenMinuteGeoid);
+        const ret = wasm.terraingeoidmodel_egm96FifteenMinute(geoid.__wbg_ptr);
+        return TerrainGeoidModel.__wrap(ret);
     }
     /**
-     * B* drag term (TLE dimensionless convention).
-     * @returns {number}
+     * Use the embedded EGM96 1-degree geoid grid for `h = H + N`.
+     * @returns {TerrainGeoidModel}
      */
-    get bstar() {
-        const ret = wasm.tle_bstar(this.__wbg_ptr);
-        return ret;
+    static egm96OneDegree() {
+        const ret = wasm.terraingeoidmodel_egm96OneDegree();
+        return TerrainGeoidModel.__wrap(ret);
     }
     /**
-     * NORAD catalog number (as recorded in the TLE).
+     * Model discriminator: `"egm96OneDegree"` or `"egm96FifteenMinute"`.
      * @returns {string}
      */
-    get catalogNumber() {
+    get kind() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tle_catalogNumber(this.__wbg_ptr);
+            const ret = wasm.terraingeoidmodel_kind(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -14174,9 +15041,269 @@ class Tle {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Advisory checksum discrepancies found while parsing. Empty when both
-     * lines' checksums are valid.
+}
+if (Symbol.dispose) TerrainGeoidModel.prototype[Symbol.dispose] = TerrainGeoidModel.prototype.free;
+exports.TerrainGeoidModel = TerrainGeoidModel;
+
+/**
+ * Terrain store conversion, serialization, and parsing error variants.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+const TerrainStoreError = Object.freeze({
+    /**
+     * File or directory I/O failed.
+     */
+    Io: 0, "0": "Io",
+    /**
+     * DTED or terrain store bytes could not be parsed.
+     */
+    Parse: 1, "1": "Parse",
+    /**
+     * The terrain store version is not supported.
+     */
+    UnsupportedVersion: 2, "2": "UnsupportedVersion",
+    /**
+     * The terrain store datum tag is not supported.
+     */
+    UnsupportedDatum: 3, "3": "UnsupportedDatum",
+    /**
+     * Two input DTED files resolved to the same integer tile id.
+     */
+    DuplicateTile: 4, "4": "DuplicateTile",
+    /**
+     * A tile payload checksum did not match its index record.
+     */
+    Checksum: 5, "5": "Checksum",
+});
+exports.TerrainStoreError = TerrainStoreError;
+
+/**
+ * Metadata for one tile index record in a memory-mappable terrain store.
+ */
+class TerrainStoreTileIndex {
+    static __wrap(ptr) {
+        const obj = Object.create(TerrainStoreTileIndex.prototype);
+        obj.__wbg_ptr = ptr;
+        TerrainStoreTileIndexFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TerrainStoreTileIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_terrainstoretileindex_free(ptr, 0);
+    }
+    /**
+     * FNV-1a checksum of this tile's posting payload bytes.
+     * @returns {bigint}
+     */
+    get checksum64() {
+        const ret = wasm.terrainstoretileindex_checksum64(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Byte length of this tile's posting payload in the store.
+     * @returns {bigint}
+     */
+    get dataLen() {
+        const ret = wasm.terrainstoretileindex_dataLen(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Byte offset of this tile's posting payload in the store.
+     * @returns {bigint}
+     */
+    get dataOffset() {
+        const ret = wasm.terrainstoretileindex_dataOffset(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Number of latitude postings.
+     * @returns {number}
+     */
+    get latCount() {
+        const ret = wasm.terrainstoretileindex_latCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Integer latitude tile id, for example `36` for a tile covering
+     * `36..37` degrees.
+     * @returns {number}
+     */
+    get latIndex() {
+        const ret = wasm.terrainstoretileindex_latIndex(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Number of longitude postings.
+     * @returns {number}
+     */
+    get lonCount() {
+        const ret = wasm.terrainstoretileindex_lonCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Integer longitude tile id, for example `-107` for a tile covering
+     * `-107..-106` degrees.
+     * @returns {number}
+     */
+    get lonIndex() {
+        const ret = wasm.terrainstoretileindex_lonIndex(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Northern edge latitude, degrees.
+     * @returns {number}
+     */
+    get maxLatitudeDeg() {
+        const ret = wasm.terrainstoretileindex_maxLatitudeDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Eastern edge longitude, degrees.
+     * @returns {number}
+     */
+    get maxLongitudeDeg() {
+        const ret = wasm.terrainstoretileindex_maxLongitudeDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Southern edge latitude, degrees.
+     * @returns {number}
+     */
+    get minLatitudeDeg() {
+        const ret = wasm.terrainstoretileindex_minLatitudeDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Western edge longitude, degrees.
+     * @returns {number}
+     */
+    get minLongitudeDeg() {
+        const ret = wasm.terrainstoretileindex_minLongitudeDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertical datum for this tile's orthometric posting payload.
+     * @returns {VerticalDatum}
+     */
+    get verticalDatum() {
+        const ret = wasm.terrainstoretileindex_verticalDatum(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) TerrainStoreTileIndex.prototype[Symbol.dispose] = TerrainStoreTileIndex.prototype.free;
+exports.TerrainStoreTileIndex = TerrainStoreTileIndex;
+
+/**
+ * A named time scale. The JS value matches the variant order below.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
+ */
+const TimeScale = Object.freeze({
+    /**
+     * Coordinated Universal Time.
+     */
+    Utc: 0, "0": "Utc",
+    /**
+     * International Atomic Time.
+     */
+    Tai: 1, "1": "Tai",
+    /**
+     * Terrestrial Time.
+     */
+    Tt: 2, "2": "Tt",
+    /**
+     * Barycentric Dynamical Time.
+     */
+    Tdb: 3, "3": "Tdb",
+    /**
+     * GPS time.
+     */
+    Gpst: 4, "4": "Gpst",
+    /**
+     * Galileo System Time.
+     */
+    Gst: 5, "5": "Gst",
+    /**
+     * BeiDou Time.
+     */
+    Bdt: 6, "6": "Bdt",
+    /**
+     * GLONASS system time (UTC(SU)-based, leap-second carrying).
+     */
+    Glonasst: 7, "7": "Glonasst",
+    /**
+     * QZSS system time (steered to GPST).
+     */
+    Qzsst: 8, "8": "Qzsst",
+});
+exports.TimeScale = TimeScale;
+
+/**
+ * A parsed two-line element set with an initialized SGP4 satellite.
+ */
+class Tle {
+    static __wrap(ptr) {
+        const obj = Object.create(Tle.prototype);
+        obj.__wbg_ptr = ptr;
+        TleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Tle)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tle_free(ptr, 0);
+    }
+    /**
+     * Argument of perigee, degrees.
+     * @returns {number}
+     */
+    get argPerigeeDeg() {
+        const ret = wasm.tle_argPerigeeDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * B* drag term (TLE dimensionless convention).
+     * @returns {number}
+     */
+    get bstar() {
+        const ret = wasm.tle_bstar(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * NORAD catalog number (as recorded in the TLE).
+     * @returns {string}
+     */
+    get catalogNumber() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tle_catalogNumber(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);
+        }
+    }
+    /**
+     * Advisory checksum discrepancies found while parsing. Empty when both
+     * lines' checksums are valid.
      * @returns {ChecksumWarning[]}
      */
     get checksumWarnings() {
@@ -14725,6 +15852,18 @@ class VelocitySolution {
 if (Symbol.dispose) VelocitySolution.prototype[Symbol.dispose] = VelocitySolution.prototype.free;
 exports.VelocitySolution = VelocitySolution;
 
+/**
+ * Vertical datum carried by a terrain store.
+ * @enum {0}
+ */
+const VerticalDatum = Object.freeze({
+    /**
+     * Orthometric height `H` in metres above the EGM96 mean sea level geoid.
+     */
+    Egm96MslOrthometric: 0, "0": "Egm96MslOrthometric",
+});
+exports.VerticalDatum = VerticalDatum;
+
 /**
  * Per-epoch topocentric visibility plus the dense pass list over the grid
  * window.
@@ -15021,6 +16160,104 @@ function acquire(samples, prn, options) {
 }
 exports.acquire = acquire;
 
+/**
+ * Plain non-overlapping Allan deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, where `kind` is `"phaseSeconds"` or
+ * `"fractionalFrequency"` and `values` are phase seconds or dimensionless
+ * fractional-frequency samples. `tau0S` is the sample interval in seconds.
+ * `averagingFactors` is an array of positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ * @param {any} series
+ * @param {number} tau0_s
+ * @param {any} averaging_factors
+ * @returns {any}
+ */
+function allanDeviation(series, tau0_s, averaging_factors) {
+    const ret = wasm.allanDeviation(series, tau0_s, averaging_factors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.allanDeviation = allanDeviation;
+
+/**
+ * Alpha-beta measurement update applied to a predicted scalar state.
+ *
+ * `predicted` is `{ level, rate }`, `measurement` has the same unit as
+ * `level`, `dt` is seconds, and `gains` is `{ alpha, beta }`.
+ * @param {any} predicted
+ * @param {number} measurement
+ * @param {number} dt
+ * @param {any} gains
+ * @returns {any}
+ */
+function alphaBetaApplyMeasurement(predicted, measurement, dt, gains) {
+    const ret = wasm.alphaBetaApplyMeasurement(predicted, measurement, dt, gains);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaApplyMeasurement = alphaBetaApplyMeasurement;
+
+/**
+ * Run one alpha-beta predict and measurement update.
+ *
+ * `state` is `{ level, rate }`, `measurement` has the same unit as `level`,
+ * `dt` is seconds, and `gains` is `{ alpha, beta }`. Returns `{ predicted,
+ * updated, innovation }`.
+ * @param {any} state
+ * @param {number} measurement
+ * @param {number} dt
+ * @param {any} gains
+ * @returns {any}
+ */
+function alphaBetaFilterStep(state, measurement, dt, gains) {
+    const ret = wasm.alphaBetaFilterStep(state, measurement, dt, gains);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaFilterStep = alphaBetaFilterStep;
+
+/**
+ * Alpha-beta constant-rate prediction.
+ *
+ * `state` is `{ level, rate }` and `dt` is the positive propagation interval in
+ * seconds. Returns the predicted `{ level, rate }`.
+ * @param {any} state
+ * @param {number} dt
+ * @returns {any}
+ */
+function alphaBetaPredict(state, dt) {
+    const ret = wasm.alphaBetaPredict(state, dt);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaPredict = alphaBetaPredict;
+
+/**
+ * Steady-state alpha-beta gains from a positive tracking index.
+ *
+ * Returns `{ alpha, beta }`, where `alpha` is the level gain and `beta` maps
+ * innovation to rate through `beta * innovation / dt`.
+ * @param {number} tracking_index
+ * @returns {any}
+ */
+function alphaBetaSteadyStateGains(tracking_index) {
+    const ret = wasm.alphaBetaSteadyStateGains(tracking_index);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.alphaBetaSteadyStateGains = alphaBetaSteadyStateGains;
+
 /**
  * On-sky angle in degrees between two direction vectors.
  * @param {Float64Array} a
@@ -15057,6 +16294,68 @@ function angularSeparationCoords(a_lon_deg, a_lat_deg, b_lon_deg, b_lat_deg) {
 }
 exports.angularSeparationCoords = angularSeparationCoords;
 
+/**
+ * Run ARAIM MHSS protection-level computation.
+ *
+ * `geometry.rows` contains satellite IDs, ECEF line-of-sight unit vectors,
+ * optional constellation labels, and elevations in radians. `receiver` is WGS84
+ * geodetic radians plus ellipsoidal height meters. `ism` contains
+ * constellation defaults and optional satellite overrides. Satellite models may
+ * provide paired `effectiveSigmaIntM` and `effectiveSigmaAccM` fields; omit both
+ * to let the core derive them from elevation. `allocation` may be omitted to use
+ * `araimLpv200Allocation()`. Returned `hplM`, `vplM`, `sigmaAccHM`,
+ * `sigmaAccVM`, `emtM`, and per-mode ENU arrays are meters.
+ * @param {any} geometry
+ * @param {any} ism
+ * @param {any} allocation
+ * @returns {any}
+ */
+function araim(geometry, ism, allocation) {
+    const ret = wasm.araim(geometry, ism, allocation);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.araim = araim;
+
+/**
+ * Enumerate ARAIM fault hypotheses for the given geometry, ISM, and allocation.
+ *
+ * Inputs mirror `araim`. The returned priors are probabilities. Excluded
+ * satellites are string tokens such as `"G01"`, and excluded constellations are
+ * labels such as `"GPS"`.
+ * @param {any} geometry
+ * @param {any} ism
+ * @param {any} allocation
+ * @returns {any}
+ */
+function araimFaultModes(geometry, ism, allocation) {
+    const ret = wasm.araimFaultModes(geometry, ism, allocation);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.araimFaultModes = araimFaultModes;
+
+/**
+ * LPV-200 ARAIM integrity and continuity allocation.
+ *
+ * The returned object can be passed to `araim`. Probability fields are
+ * dimensionless, `pEmt` defaults to `1e-5`, and `maxFaultOrder` is an integer
+ * fault order.
+ * @returns {any}
+ */
+function araimLpv200Allocation() {
+    const ret = wasm.araimLpv200Allocation();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.araimLpv200Allocation = araimLpv200Allocation;
+
 /**
  * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
  *
@@ -15231,6 +16530,92 @@ function carrierFrequencyHz(system, band) {
 }
 exports.carrierFrequencyHz = carrierFrequencyHz;
 
+/**
+ * CA-CFAR false alarm probability from searched-cell count, absolute
+ * threshold, and mean noise level.
+ * @param {number} searched_cells
+ * @param {number} threshold
+ * @param {number} noise_level
+ * @returns {number}
+ */
+function cfarCaFalseAlarmProbability(searched_cells, threshold, noise_level) {
+    const ret = wasm.cfarCaFalseAlarmProbability(searched_cells, threshold, noise_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaFalseAlarmProbability = cfarCaFalseAlarmProbability;
+
+/**
+ * CA-CFAR threshold multiplier from searched-cell count and target false alarm
+ * probability.
+ * @param {number} searched_cells
+ * @param {number} false_alarm_probability
+ * @returns {number}
+ */
+function cfarCaMultiplierFromPfa(searched_cells, false_alarm_probability) {
+    const ret = wasm.cfarCaMultiplierFromPfa(searched_cells, false_alarm_probability);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaMultiplierFromPfa = cfarCaMultiplierFromPfa;
+
+/**
+ * CA-CFAR false alarm probability from searched-cell count and multiplier.
+ * @param {number} searched_cells
+ * @param {number} multiplier
+ * @returns {number}
+ */
+function cfarCaPfaFromMultiplier(searched_cells, multiplier) {
+    const ret = wasm.cfarCaPfaFromMultiplier(searched_cells, multiplier);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaPfaFromMultiplier = cfarCaPfaFromMultiplier;
+
+/**
+ * CA-CFAR absolute threshold from searched-cell count, target false alarm
+ * probability, and mean noise level.
+ * @param {number} searched_cells
+ * @param {number} false_alarm_probability
+ * @param {number} noise_level
+ * @returns {number}
+ */
+function cfarCaThreshold(searched_cells, false_alarm_probability, noise_level) {
+    const ret = wasm.cfarCaThreshold(searched_cells, false_alarm_probability, noise_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.cfarCaThreshold = cfarCaThreshold;
+
+/**
+ * Compute the closed-form Chan-Ho seed used by [`locateSource`].
+ *
+ * `mode` is `"toa"`, `"tdoa"`, or `{ mode: "tdoa", referenceSensor }`.
+ * Per-sensor speed overrides are not used by the closed-form equations, but
+ * they are used by [`locateSource`] during iterative refinement.
+ * @param {any} sensors
+ * @param {any} arrival_times_s
+ * @param {number} propagation_speed_m_s
+ * @param {any} mode
+ * @returns {any}
+ */
+function chanHoInitialGuess(sensors, arrival_times_s, propagation_speed_m_s, mode) {
+    const ret = wasm.chanHoInitialGuess(sensors, arrival_times_s, propagation_speed_m_s, mode);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.chanHoInitialGuess = chanHoInitialGuess;
+
 /**
  * Returns `true` when a diff has any findings.
  * @param {any} diff
@@ -15392,6 +16777,29 @@ function collisionProbability(object1, object2, hard_body_radius_km, method) {
 }
 exports.collisionProbability = collisionProbability;
 
+/**
+ * Compute one or more Allan-family curves with a selected tau grid and gap
+ * policy.
+ *
+ * `input` is `{ series, tau0S, options? }`. `series.kind` may be
+ * `"phaseSeconds"`, `"fractionalFrequency"`, `"phaseSecondsWithGaps"`, or
+ * `"fractionalFrequencyWithGaps"`; gap series use `null` for missing samples.
+ * `options.estimators` is `"standard"`, `"all"`, `"none"`, or a boolean flag
+ * object. `options.tauGrid` is `"octave"`, `"all"`, or
+ * `{ kind: "explicit", averagingFactors }`. `tau0S` and all returned `tauS`
+ * values are seconds.
+ * @param {any} input
+ * @returns {any}
+ */
+function computeAllanDeviations(input) {
+    const ret = wasm.computeAllanDeviations(input);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.computeAllanDeviations = computeAllanDeviations;
+
 /**
  * Coherently correlate interleaved IQ samples against a GPS C/A PRN replica.
  * `iq` is `[i0, q0, i1, q1, ...]`.
@@ -15662,6 +17070,12 @@ function decodeRtcmStream(bytes) {
 exports.decodeRtcmStream = decodeRtcmStream;
 
 /**
+ * Decode a raw SBAS message.
+ *
+ * `form` is `"framed250"` for a 32-byte message with CRC or `"body226"` for a
+ * 29-byte body. The result contains `messageType`, `form`, legacy debug
+ * `kind`, and `message`, a structured decoded payload. Parse failures are
+ * thrown as `Error`.
  * @param {Uint8Array} bytes
  * @param {string | null} [form]
  * @returns {any}
@@ -15907,6 +17321,27 @@ function dopplerToRangeRate(doppler_hz, carrier_hz) {
 }
 exports.dopplerToRangeRate = dopplerToRangeRate;
 
+/**
+ * Convert a DTED tile tree into canonical memory-mappable terrain store bytes.
+ *
+ * The returned `Uint8Array` can be passed to [`MmapTerrain.fromBytes`] or
+ * [`MmapTerrain.fromVec`]. Posting payloads are decoded orthometric metres.
+ * @param {string} root
+ * @returns {Uint8Array}
+ */
+function dtedTreeToMmapStore(root) {
+    const ptr0 = passStringToWasm0(root, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dtedTreeToMmapStore(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.dtedTreeToMmapStore = dtedTreeToMmapStore;
+
 /**
  * Angular radius in degrees of Earth as seen from each satellite position.
  * @param {Float64Array} satellite_position_km
@@ -16307,22 +17742,57 @@ 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}
+ * 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;
+
+/**
+ * Exponentially weighted moving-average update.
+ *
+ * `alpha` must be in `[0, 1]`; the returned value is
+ * `previous + alpha * (sample - previous)`.
+ * @param {number} previous
+ * @param {number} sample
+ * @param {number} alpha
+ * @returns {number}
+ */
+function ewmaUpdate(previous, sample, alpha) {
+    const ret = wasm.ewmaUpdate(previous, sample, alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.ewmaUpdate = ewmaUpdate;
+
+/**
+ * EWMA update with `alpha = 1 / 2^shift`.
+ * @param {number} previous
+ * @param {number} sample
+ * @param {number} shift
+ * @returns {number}
  */
-function estimateDecayWithSpaceWeather(drag, table, request) {
-    _assertClass(drag, DragForce);
-    _assertClass(table, SpaceWeatherTable);
-    const ret = wasm.estimateDecayWithSpaceWeather(drag.__wbg_ptr, table.__wbg_ptr, request);
+function ewmaUpdatePowerOfTwo(previous, sample, shift) {
+    const ret = wasm.ewmaUpdatePowerOfTwo(previous, sample, shift);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return ret[0];
 }
-exports.estimateDecayWithSpaceWeather = estimateDecayWithSpaceWeather;
+exports.ewmaUpdatePowerOfTwo = ewmaUpdatePowerOfTwo;
 
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
@@ -17192,6 +18662,26 @@ function gpsUtcOffsetS(year, month, day) {
 }
 exports.gpsUtcOffsetS = gpsUtcOffsetS;
 
+/**
+ * Overlapping Hadamard deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, `tau0S` is seconds, and
+ * `averagingFactors` contains positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ * @param {any} series
+ * @param {number} tau0_s
+ * @param {any} averaging_factors
+ * @returns {any}
+ */
+function hadamardDeviation(series, tau0_s, averaging_factors) {
+    const ret = wasm.hadamardDeviation(series, tau0_s, averaging_factors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.hadamardDeviation = hadamardDeviation;
+
 /**
  * Trace of the Gauss-Newton Hessian approximation `J^T J`: the sum of the
  * squared column norms of the Jacobian, with no inverse formed.
@@ -17305,6 +18795,49 @@ function iodHerrickGibbs(r1, r2, r3, jd1, jd2, jd3) {
 }
 exports.iodHerrickGibbs = iodHerrickGibbs;
 
+/**
+ * Build an IONEX vertical-TEC product from flat node samples.
+ *
+ * `samples` is an array of `{ epochJ2000S, latDeg, lonDeg, vtecTecu,
+ * rmsTecu? }` objects. Epochs are integer seconds since J2000, coordinates are
+ * degrees, and TEC/RMS values are TECU. `shellHeightKm` and `baseRadiusKm` are
+ * kilometers. Validation errors from the core sample builder are thrown as
+ * `RangeError`.
+ * @param {any} samples
+ * @param {number} shell_height_km
+ * @param {number} base_radius_km
+ * @param {number} exponent
+ * @returns {Ionex}
+ */
+function ionexFromNodeSamples(samples, shell_height_km, base_radius_km, exponent) {
+    const ret = wasm.ionexFromNodeSamples(samples, shell_height_km, base_radius_km, exponent);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Ionex.__wrap(ret[0]);
+}
+exports.ionexFromNodeSamples = ionexFromNodeSamples;
+
+/**
+ * Build an IONEX vertical-TEC product from full-grid samples.
+ *
+ * `samples.mapEpochsJ2000S` are integer seconds since J2000. Latitude and
+ * longitude nodes and `dlatDeg` / `dlonDeg` are degrees. `tecMaps` and
+ * `rmsMaps` are TECU and indexed `[map][iLat][iLon]`. The shell height and
+ * base radius are kilometers. Validation errors from the core sample builder
+ * are thrown as `RangeError`.
+ * @param {any} samples
+ * @returns {Ionex}
+ */
+function ionexFromSamples(samples) {
+    const ret = wasm.ionexFromSamples(samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Ionex.__wrap(ret[0]);
+}
+exports.ionexFromSamples = ionexFromSamples;
+
 /**
  * Ionosphere-free code or meter-valued phase combination, metres.
  * @param {number} obs1_m
@@ -17443,6 +18976,26 @@ function jarqueBera(x) {
 }
 exports.jarqueBera = jarqueBera;
 
+/**
+ * Steady-state gains for a scalar constant-velocity Kalman filter.
+ *
+ * `trackingIndex`, `dt`, and `measurementVariance` must be positive. Returns
+ * `{ positionGain, rateGain }`; `rateGain * dt` equals the alpha-beta `beta`
+ * gain for the same tracking index.
+ * @param {number} tracking_index
+ * @param {number} dt
+ * @param {number} measurement_variance
+ * @returns {any}
+ */
+function kalmanCvSteadyStateGains(tracking_index, dt, measurement_variance) {
+    const ret = wasm.kalmanCvSteadyStateGains(tracking_index, dt, measurement_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.kalmanCvSteadyStateGains = kalmanCvSteadyStateGains;
+
 /**
  * GPS broadcast Klobuchar ionospheric group delay in the model's native units
  * (positive metres).
@@ -18013,6 +19566,30 @@ function loadSp3(bytes) {
 }
 exports.loadSp3 = loadSp3;
 
+/**
+ * Locate a source from sensor arrival times.
+ *
+ * `sensors` is an array of `{ positionM, propagationSpeedMS? }`; each
+ * `positionM` is a 2D or 3D Cartesian metre vector and all sensors must share
+ * the same dimension. `arrivalTimesS` is an aligned seconds array,
+ * `propagationSpeedMS` is the call-level speed in metres per second, and
+ * `options` may include `mode`, `referenceSensor`, `timingSigmaS`, `loss`,
+ * `fScaleS`, `ftol`, `xtol`, `gtol`, and `maxNfev`.
+ * @param {any} sensors
+ * @param {any} arrival_times_s
+ * @param {number} propagation_speed_m_s
+ * @param {any} options
+ * @returns {any}
+ */
+function locateSource(sensors, arrival_times_s, propagation_speed_m_s, options) {
+    const ret = wasm.locateSource(sensors, arrival_times_s, propagation_speed_m_s, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.locateSource = locateSource;
+
 /**
  * @param {bigint} start_unix_us
  * @param {bigint} end_unix_us
@@ -18067,6 +19644,35 @@ function lvlhRotation(position_km, velocity_km_s) {
 }
 exports.lvlhRotation = lvlhRotation;
 
+/**
+ * Gaussian consistency factor applied by [`madSpread`].
+ * @returns {number}
+ */
+function madGaussianConsistency() {
+    const ret = wasm.madGaussianConsistency();
+    return ret;
+}
+exports.madGaussianConsistency = madGaussianConsistency;
+
+/**
+ * Median absolute deviation spread estimate.
+ *
+ * `values` is a JS number array. The returned spread is
+ * `MAD_GAUSSIAN_CONSISTENCY * median(abs(value - median(values)))`, floored by
+ * `scaleFloor`.
+ * @param {any} values
+ * @param {number} scale_floor
+ * @returns {number}
+ */
+function madSpread(values, scale_floor) {
+    const ret = wasm.madSpread(values, scale_floor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.madSpread = madSpread;
+
 /**
  * @param {number} radius_km
  * @returns {number}
@@ -18257,6 +19863,26 @@ function meridianTransitsSpk(spk, body, station, start_unix_us, end_unix_us, ste
 }
 exports.meridianTransitsSpk = meridianTransitsSpk;
 
+/**
+ * Modified Allan deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, `tau0S` is seconds, and
+ * `averagingFactors` contains positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ * @param {any} series
+ * @param {number} tau0_s
+ * @param {any} averaging_factors
+ * @returns {any}
+ */
+function modifiedAdev(series, tau0_s, averaging_factors) {
+    const ret = wasm.modifiedAdev(series, tau0_s, averaging_factors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.modifiedAdev = modifiedAdev;
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -18479,6 +20105,69 @@ function nequickGStecTecu(_eval) {
 }
 exports.nequickGStecTecu = nequickGStecTecu;
 
+/**
+ * Scalar normalized innovation squared statistic.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @returns {number}
+ */
+function nis(innovation, innovation_variance) {
+    const ret = wasm.nis(innovation, innovation_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nis = nis;
+
+/**
+ * Bar-Shalom expected NIS value for `dof` measurement degrees of freedom.
+ * @param {number} dof
+ * @returns {number}
+ */
+function nisExpectedValue(dof) {
+    const ret = wasm.nisExpectedValue(dof);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nisExpectedValue = nisExpectedValue;
+
+/**
+ * Test a scalar innovation against a chi-square NIS gate.
+ *
+ * Returns `{ nis, threshold, inGate, dof }`, with `confidence` in `(0, 1)`.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @param {number} dof
+ * @param {number} confidence
+ * @returns {any}
+ */
+function nisGate(innovation, innovation_variance, dof, confidence) {
+    const ret = wasm.nisGate(innovation, innovation_variance, dof, confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.nisGate = nisGate;
+
+/**
+ * Chi-square NIS gate threshold for `dof` and confidence probability.
+ * @param {number} dof
+ * @param {number} confidence
+ * @returns {number}
+ */
+function nisGateThreshold(dof, confidence) {
+    const ret = wasm.nisGateThreshold(dof, confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.nisGateThreshold = nisGateThreshold;
+
 /**
  * Parse bytes and return grouped epoch snapshots directly.
  * @param {Uint8Array} bytes
@@ -18566,6 +20255,21 @@ function normalCovariance(jacobian, m, n, variance_scale) {
 }
 exports.normalCovariance = normalCovariance;
 
+/**
+ * Scalar normalized innovation `innovation / sqrt(innovationVariance)`.
+ * @param {number} innovation
+ * @param {number} innovation_variance
+ * @returns {number}
+ */
+function normalizedInnovation(innovation, innovation_variance) {
+    const ret = wasm.normalizedInnovation(innovation, innovation_variance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.normalizedInnovation = normalizedInnovation;
+
 /**
  * Build the NTRIP connection request bytes for a config object.
  * @param {any} config
@@ -18582,6 +20286,24 @@ function ntripRequestBytes(config) {
 }
 exports.ntripRequestBytes = ntripRequestBytes;
 
+/**
+ * Missing-position sentinel used in failed observable-state batch elements.
+ *
+ * The returned JS value is `[NaN, NaN, NaN]`, matching
+ * `sidereon_core::ephemeris::OBSERVABLE_STATE_MISSING_POSITION_ECEF_M`. Always
+ * check `elementResults[i].ok` or `statuses[i]` before using
+ * `positionsEcefM[i]`.
+ * @returns {any}
+ */
+function observableStateMissingPositionEcefM() {
+    const ret = wasm.observableStateMissingPositionEcefM();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observableStateMissingPositionEcefM = observableStateMissingPositionEcefM;
+
 /**
  * Predict observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -18778,6 +20500,26 @@ function orthometricHeightM(ellipsoidal_height_m, lat_rad, lon_rad) {
 }
 exports.orthometricHeightM = orthometricHeightM;
 
+/**
+ * Fully overlapping Allan deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, `tau0S` is seconds, and
+ * `averagingFactors` contains positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ * @param {any} series
+ * @param {number} tau0_s
+ * @param {any} averaging_factors
+ * @returns {any}
+ */
+function overlappingAdev(series, tau0_s, averaging_factors) {
+    const ret = wasm.overlappingAdev(series, tau0_s, averaging_factors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.overlappingAdev = overlappingAdev;
+
 /**
  * Parallactic angle (degrees) of a target at a station.
  *
@@ -19996,6 +21738,23 @@ function sampleSp3Ephemeris(sp3, satellites, start_j2000_s, stop_j2000_s, step_s
 }
 exports.sampleSp3Ephemeris = sampleSp3Ephemeris;
 
+/**
+ * Convert an SBAS satellite token such as `"S29"` to broadcast PRN number
+ * such as `129`. Returns `null` for non-SBAS satellites.
+ * @param {string} sat
+ * @returns {any}
+ */
+function satToSbasPrn(sat) {
+    const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.satToSbasPrn(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.satToSbasPrn = satToSbasPrn;
+
 /**
  * Apparent visual magnitude of a sunlit body from a diffuse-sphere phase law.
  *
@@ -20020,6 +21779,10 @@ function satelliteVisualMagnitude(range_km, phase_angle_deg, standard_magnitude,
 exports.satelliteVisualMagnitude = satelliteVisualMagnitude;
 
 /**
+ * SBAS-corrected broadcast satellite position and clock.
+ *
+ * Position is ECEF meters and clock is seconds at `tJ2000S`, seconds since
+ * J2000. Returns `null` when the selected SBAS mode cannot provide a state.
  * @param {BroadcastEphemeris} broadcast
  * @param {SbasCorrectionStore} store
  * @param {string} geo
@@ -20045,6 +21808,18 @@ function sbasCorrectedState(broadcast, store, geo, sat, t_j2000_s, mode) {
 }
 exports.sbasCorrectedState = sbasCorrectedState;
 
+/**
+ * Convert an SBAS broadcast PRN number such as `129` to an SBAS satellite
+ * token such as `"S29"`. Returns `null` when the PRN is outside the SBAS range.
+ * @param {number} broadcast_prn
+ * @returns {any}
+ */
+function sbasPrnToSat(broadcast_prn) {
+    const ret = wasm.sbasPrnToSat(broadcast_prn);
+    return ret;
+}
+exports.sbasPrnToSat = sbasPrnToSat;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -20629,6 +22404,11 @@ function solveRtkFloat(config) {
 exports.solveRtkFloat = solveRtkFloat;
 
 /**
+ * Solve SPP using an SBAS-corrected broadcast source and optional SBAS iono.
+ *
+ * The returned solution uses the same units as `solveSpp`: ECEF meters,
+ * receiver clock seconds, residual meters, and optional geodetic radians plus
+ * ellipsoidal height meters.
  * @param {BroadcastEphemeris} broadcast
  * @param {SbasCorrectionStore} store
  * @param {string} geo
@@ -20745,6 +22525,78 @@ function solveWithFallback(precise, broadcast, request, policy) {
 }
 exports.solveWithFallback = solveWithFallback;
 
+/**
+ * Compute the timing Cramer-Rao lower bound for a proposed source position.
+ *
+ * The covariance is `(H^T H)^-1 * timingSigmaS^2`; position blocks are square
+ * metres and origin-time variance is square seconds.
+ * @param {any} sensors
+ * @param {any} source_position_m
+ * @param {number} propagation_speed_m_s
+ * @param {number} timing_sigma_s
+ * @returns {any}
+ */
+function sourceCrlb(sensors, source_position_m, propagation_speed_m_s, timing_sigma_s) {
+    const ret = wasm.sourceCrlb(sensors, source_position_m, propagation_speed_m_s, timing_sigma_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceCrlb = sourceCrlb;
+
+/**
+ * Compute timing DOP for a proposed source position.
+ *
+ * `sourcePositionM` is a 2D or 3D Cartesian metre vector in the same frame as
+ * the sensors. The returned DOP values multiply timing sigma in seconds to
+ * produce metres in the caller's Cartesian axes.
+ * @param {any} sensors
+ * @param {any} source_position_m
+ * @param {number} propagation_speed_m_s
+ * @returns {any}
+ */
+function sourceDop(sensors, source_position_m, propagation_speed_m_s) {
+    const ret = wasm.sourceDop(sensors, source_position_m, propagation_speed_m_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceDop = sourceDop;
+
+/**
+ * Return the plain mode object for TDOA solves against `referenceSensor`.
+ * @param {number} reference_sensor
+ * @returns {any}
+ */
+function sourceSolveModeTdoa(reference_sensor) {
+    const ret = wasm.sourceSolveModeTdoa(reference_sensor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sourceSolveModeTdoa = sourceSolveModeTdoa;
+
+/**
+ * Return the plain mode value for absolute time-of-arrival solves.
+ * @returns {string}
+ */
+function sourceSolveModeToa() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.sourceSolveModeToa();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.sourceSolveModeToa = sourceSolveModeToa;
+
 /**
  * Extract a parsed SP3 product as the canonical precise-ephemeris samples, one
  * per real position record in ascending epoch order.
@@ -21031,6 +22883,39 @@ function terminatorLatitudeDeg(sub_solar_latitude_deg, sub_solar_longitude_deg,
 }
 exports.terminatorLatitudeDeg = terminatorLatitudeDeg;
 
+/**
+ * Return an FNV-1a checksum for terrain store bytes.
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+function terrainStoreChecksum64(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.terrainStoreChecksum64(ptr0, len0);
+    return BigInt.asUintN(64, ret);
+}
+exports.terrainStoreChecksum64 = terrainStoreChecksum64;
+
+/**
+ * Time deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, `tau0S` is seconds, and
+ * `averagingFactors` contains positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ * @param {any} series
+ * @param {number} tau0_s
+ * @param {any} averaging_factors
+ * @returns {any}
+ */
+function timeDeviation(series, tau0_s, averaging_factors) {
+    const ret = wasm.timeDeviation(series, tau0_s, averaging_factors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.timeDeviation = timeDeviation;
+
 /**
  * Short uppercase identifier for a time scale, e.g. `"GPST"`.
  * @param {TimeScale} scale
@@ -21400,6 +23285,23 @@ function wideLaneWavelength(f1_hz, f2_hz) {
     return ret[0];
 }
 exports.wideLaneWavelength = wideLaneWavelength;
+
+/**
+ * Convert a DTED tile tree and write canonical terrain store bytes to a path.
+ * @param {string} root
+ * @param {string} out_path
+ */
+function writeDtedTreeToMmapStore(root, out_path) {
+    const ptr0 = passStringToWasm0(root, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(out_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.writeDtedTreeToMmapStore(ptr0, len0, ptr1, len1);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.writeDtedTreeToMmapStore = writeDtedTreeToMmapStore;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -21780,6 +23682,10 @@ function __wbg_get_imports() {
             const ret = SpkSegment.__wrap(arg0);
             return ret;
         },
+        __wbg_terrainstoretileindex_new: function(arg0) {
+            const ret = TerrainStoreTileIndex.__wrap(arg0);
+            return ret;
+        },
         __wbg_tle_unwrap: function(arg0) {
             const ret = Tle.__unwrap(arg0);
             return ret;
@@ -21942,6 +23848,12 @@ const DragForceFinalization = (typeof FinalizationRegistry === 'undefined')
 const DtedTerrainFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dtedterrain_free(ptr, 1));
+const Egm96FifteenMinuteGeoidFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_egm96fifteenminutegeoid_free(ptr, 1));
+const EllipsoidalHeightMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ellipsoidalheightm_free(ptr, 1));
 const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_encounterframe_free(ptr, 1));
@@ -22050,6 +23962,9 @@ const LookAnglesFinalization = (typeof FinalizationRegistry === 'undefined')
 const MappingFactorsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mappingfactors_free(ptr, 1));
+const MmapTerrainFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mmapterrain_free(ptr, 1));
 const MoonElevationCrossingFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_moonelevationcrossing_free(ptr, 1));
@@ -22134,6 +24049,9 @@ const OpmSpacecraftFinalization = (typeof FinalizationRegistry === 'undefined')
 const OpmStateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_opmstate_free(ptr, 1));
+const OrthometricHeightMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orthometricheightm_free(ptr, 1));
 const ParsedTleFileFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_parsedtlefile_free(ptr, 1));
@@ -22149,6 +24067,9 @@ const PppFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined
 const PppFloatSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pppfloatsolution_free(ptr, 1));
+const PreciseEphemerisInterpolantFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerisinterpolant_free(ptr, 1));
 const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));
@@ -22275,6 +24196,12 @@ const SsrCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefin
 const SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sunmoon_free(ptr, 1));
+const TerrainGeoidModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_terraingeoidmodel_free(ptr, 1));
+const TerrainStoreTileIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_terrainstoretileindex_free(ptr, 1));
 const TleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tle_free(ptr, 1));