@neilberkman/sidereon 0.11.1 → 0.13.0

package/pkg-node/sidereon.d.ts

@@ -305,6 +305,25 @@ export class BroadcastEphemeris {
      * J2000 seconds. Returns `undefined` when no usable record covers the query.
      */
     evaluate(satellite: string, t_j2000_s: number): BroadcastStoreEvaluation | undefined;
+    /**
+     * 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.
+     */
+    observableStatesAtJ2000S(satellites: any, epochs_j2000_s: any): any;
+    /**
+     * 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).
+     */
+    observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
     /**
      * Solve a receiver position from broadcast ephemeris ALONE: the supported
      * real-time / offline single-point-positioning mode. `request` is the same
@@ -1454,14 +1473,84 @@ export class DragForce {
     readonly spaceWeather: SpaceWeather;
 }
 
+/**
+ * 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.
+ */
 export class DtedTerrain {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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`.
+     */
+    heightBatch(points: any, options: any): any;
+    /**
+     * 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.
+     */
     heightM(longitude_deg: number, latitude_deg: number): number;
+    /**
+     * 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.
+     */
     heightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): number;
+    /**
+     * 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.
+     */
     constructor(root: string);
 }
 
+/**
+ * Loaded EGM96 15-arcminute geoid grid for explicit terrain datum conversion.
+ */
+export class Egm96FifteenMinuteGeoid {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Load `WW15MGH.DAC` bytes as an EGM96 15-arcminute geoid grid.
+     */
+    static fromWw15mghDacBytes(bytes: Uint8Array): Egm96FifteenMinuteGeoid;
+    /**
+     * Read and load `WW15MGH.DAC` from disk. A missing file throws a typed
+     * `MissingEgm96Dac` error with `path` and `remediation` fields.
+     */
+    static fromWw15mghDacPath(path: string): Egm96FifteenMinuteGeoid;
+}
+
+/**
+ * Ellipsoidal height `h` in metres above the WGS84 reference ellipsoid.
+ */
+export class EllipsoidalHeightM {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an ellipsoidal height `h` in metres.
+     */
+    constructor(value_m: number);
+    /**
+     * Ellipsoidal height `h`, metres above the WGS84 reference ellipsoid.
+     */
+    readonly valueM: number;
+}
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -2160,6 +2249,22 @@ export class Ionex {
      * a `RangeError` on non-finite input and an `Error` on out-of-range input.
      */
     slantDelay(lat_deg: number, lon_deg: number, azimuth_deg: number, elevation_deg: number, epoch_j2000_s: number, frequency_hz: number): number;
+    /**
+     * 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.
+     */
+    tecGridSamples(): any;
+    /**
+     * 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.
+     */
+    tecSamples(): any;
     /**
      * Serialize to standard IONEX text. Deterministic: the same product always
      * produces byte-identical text, and re-parsing the output yields an equal
@@ -2171,6 +2276,16 @@ export class Ionex {
      * Mean Earth radius used by the geometry, kilometres.
      */
     readonly baseRadiusKm: number;
+    /**
+     * Signed latitude grid step, degrees. Standard IONEX grids are
+     * north-to-south, so this value is usually negative.
+     */
+    readonly dlatDeg: number;
+    /**
+     * Signed longitude grid step, degrees. Standard IONEX grids are
+     * west-to-east, so this value is usually positive.
+     */
+    readonly dlonDeg: number;
     /**
      * The IONEX `EXPONENT` header field; the TEC scale is `10^exponent`.
      */
@@ -2732,6 +2847,104 @@ export class MappingFactors {
     readonly wet: number;
 }
 
+/**
+ * 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.
+ */
+export class MmapTerrain {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * FNV-1a checksum of the full terrain store byte span.
+     */
+    checksum64(): bigint;
+    /**
+     * Ellipsoidal height `h = H + N` in metres at `(longitudeDeg, latitudeDeg)`
+     * using the embedded EGM96 1-degree geoid grid.
+     */
+    ellipsoidalHeightM(longitude_deg: number, latitude_deg: number): EllipsoidalHeightM;
+    /**
+     * 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.
+     */
+    ellipsoidalHeightMWithModel(longitude_deg: number, latitude_deg: number, options: any, geoid: TerrainGeoidModel): EllipsoidalHeightM;
+    /**
+     * Ellipsoidal height `h = H + N` in metres using embedded EGM96 1-degree
+     * geoid conversion and explicit terrain lookup options.
+     */
+    ellipsoidalHeightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): EllipsoidalHeightM;
+    /**
+     * Parse terrain store bytes from a `Uint8Array`.
+     */
+    static fromBytes(bytes: Uint8Array): MmapTerrain;
+    /**
+     * Read a terrain store file from host I/O and parse it into memory.
+     *
+     * Browser runtimes should use [`MmapTerrain.fromBytes`] with fetched bytes.
+     */
+    static fromPath(path: string): MmapTerrain;
+    /**
+     * Parse terrain store bytes from an owned `Uint8Array` copy.
+     */
+    static fromVec(bytes: Uint8Array): MmapTerrain;
+    /**
+     * 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 }`.
+     */
+    heightBatch(points: any, options: any): any;
+    /**
+     * Terrain height in ORTHOMETRIC metres at `(longitudeDeg, latitudeDeg)`.
+     *
+     * Longitude and latitude are degrees. The lookup uses bilinear
+     * interpolation. Missing tiles evaluate to `0.0`.
+     */
+    heightM(longitude_deg: number, latitude_deg: number): number;
+    /**
+     * Terrain height in ORTHOMETRIC metres at `(longitudeDeg, latitudeDeg)`.
+     *
+     * `options.interpolation` is `"bilinear"`, `"nearest"`, or
+     * `"nearestPosting"`.
+     */
+    heightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): number;
+    /**
+     * Batch typed ORTHOMETRIC terrain heights for longitude-first points.
+     *
+     * Each entry is `{ ok: true, orthometricHeightM: { valueM } }` or
+     * `{ ok: false, error }`.
+     */
+    orthometricHeightBatch(points: any, options: any): any;
+    /**
+     * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`.
+     */
+    orthometricHeightM(longitude_deg: number, latitude_deg: number): OrthometricHeightM;
+    /**
+     * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`
+     * with explicit lookup options.
+     */
+    orthometricHeightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): OrthometricHeightM;
+    /**
+     * Parsed tile index records in store order.
+     */
+    tileIndex(): TerrainStoreTileIndex[];
+    /**
+     * Canonical store bytes for this parsed terrain store.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * File-level vertical datum for the store's orthometric posting payloads.
+     */
+    readonly verticalDatum: VerticalDatum;
+}
+
 /**
  * One refined Moon elevation threshold crossing (moonrise / moonset).
  */
@@ -3782,6 +3995,33 @@ export class OpmState {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * Orthometric terrain height `H` in metres above the EGM96 mean sea level
+ * geoid.
+ */
+export class OrthometricHeightM {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an orthometric height `H` in metres.
+     */
+    constructor(value_m: number);
+    /**
+     * Convert to ellipsoidal height `h = H + N` using degree inputs in geoid
+     * order `(latitudeDeg, longitudeDeg)` and an explicit geoid model.
+     */
+    toEllipsoidalHeightDeg(latitude_deg: number, longitude_deg: number, geoid: TerrainGeoidModel): EllipsoidalHeightM;
+    /**
+     * Convert to ellipsoidal height `h = H + N` using radian inputs in geoid
+     * order `(latitudeRad, longitudeRad)` and an explicit geoid model.
+     */
+    toEllipsoidalHeightRad(latitude_rad: number, longitude_rad: number, geoid: TerrainGeoidModel): EllipsoidalHeightM;
+    /**
+     * Orthometric height `H`, metres above the EGM96 mean sea level geoid.
+     */
+    readonly valueM: number;
+}
+
 /**
  * The result of [`parseTleFile`]: the satellites that parsed, plus a count of
  * complete records that were skipped because SGP4 initialization failed.
@@ -3958,6 +4198,80 @@ export class PppFloatSolution {
     readonly ztdResidualM: number | undefined;
 }
 
+/**
+ * A reusable precise-ephemeris interpolant with cached per-satellite nodes.
+ *
+ * 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.
+ */
+export class PreciseEphemerisInterpolant {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a cached interpolant from an existing sample-backed precise source.
+     */
+    static fromPreciseEphemerisSamples(source: PreciseEphemerisSampleSource): PreciseEphemerisInterpolant;
+    /**
+     * 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.
+     */
+    static fromSamples(samples: any): PreciseEphemerisInterpolant;
+    /**
+     * 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.
+     */
+    static fromSp3(sp3: Sp3): PreciseEphemerisInterpolant;
+    /**
+     * 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.
+     */
+    observableStatesAtJ2000S(satellites: any, epochs_j2000_s: any): any;
+    /**
+     * 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).
+     */
+    observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
+    /**
+     * 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`].
+     */
+    predictRanges(requests: any, options: any): any;
+    /**
+     * Satellite tokens this handle can interpolate, ascending.
+     */
+    readonly satellites: string[];
+    /**
+     * Source time-scale abbreviation used by this handle's J2000-second axis,
+     * such as `"GPST"`.
+     */
+    readonly timeScale: string;
+}
+
 /**
  * A precise-ephemeris source built from samples rather than parsed SP3 text.
  *
@@ -3969,6 +4283,26 @@ export class PreciseEphemerisSampleSource {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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`.
+     */
+    observableStatesAtJ2000S(satellites: any, epochs_j2000_s: any): any;
+    /**
+     * 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).
+     */
+    observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
     /**
      * Predict geometric ranges for many requests in one call. See the shared
      * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
@@ -4518,13 +4852,80 @@ export class SatelliteVector {
     readonly values: Float64Array;
 }
 
+/**
+ * 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.
+ */
 export class SbasCorrectionStore {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Fast pseudorange correction for `(geo, sat)`, or `null`.
+     *
+     * `prcM` is meters, `rrcMS` is meters per second, and `tOfJ2000S` is
+     * seconds since J2000.
+     */
+    fastCorrection(geo: string, sat: string): any;
+    /**
+     * 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.
+     */
+    geoNavState(geo: string): any;
+    /**
+     * 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"`.
+     */
     ingest(bytes: Uint8Array, form: string | null | undefined, geo: string, week: number, tow_s: number, time_scale?: string | null): void;
+    /**
+     * 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.
+     */
+    ionoGrid(geo: string): any;
+    /**
+     * 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.
+     */
     ionoSlantDelayM(geo: string, receiver_lat_rad: number, receiver_lon_rad: number, receiver_height_m: number, elevation_rad: number, azimuth_rad: number, frequency_hz: number): number | undefined;
+    /**
+     * 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.
+     */
+    longTermCorrection(geo: string, sat: string): any;
+    /**
+     * Create an empty SBAS correction store.
+     */
     constructor();
+    /**
+     * 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.
+     */
     readyGeos(t_j2000_s: number): string[];
+    /**
+     * Allow or disallow partial SBAS corrections when building corrected
+     * ephemeris states.
+     */
+    setAllowPartial(yes: boolean): void;
+    /**
+     * Set the maximum staleness for fresh SBAS corrections, in seconds.
+     */
+    setStalenessSeconds(seconds: number): void;
 }
 
 /**
@@ -4706,6 +5107,26 @@ export class Sp3 {
      * coverage gap (the engine refuses to extrapolate).
      */
     interpolate(satellite: string, j2000_seconds: Float64Array): Sp3Interpolation;
+    /**
+     * 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`.
+     */
+    observableStatesAtJ2000S(satellites: any, epochs_j2000_s: any): any;
+    /**
+     * 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).
+     */
+    observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -5296,6 +5717,139 @@ export class SunMoon {
     readonly sun: Float64Array;
 }
 
+/**
+ * Terrain datum conversion and optional geoid-grid loading error variants.
+ */
+export enum TerrainDatumError {
+    /**
+     * Terrain lookup failed before datum conversion.
+     */
+    Terrain = 0,
+    /**
+     * A geoid grid could not be parsed.
+     */
+    Geoid = 1,
+    /**
+     * Reading a geoid grid failed for a reason other than absence.
+     */
+    Io = 2,
+    /**
+     * The EGM96 15-arcminute `WW15MGH.DAC` grid was requested but is absent.
+     */
+    MissingEgm96Dac = 3,
+}
+
+/**
+ * Geoid model used to convert terrain orthometric height `H` to ellipsoidal
+ * height `h`.
+ */
+export class TerrainGeoidModel {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Use a caller-supplied EGM96 15-arcminute geoid grid for `h = H + N`.
+     */
+    static egm96FifteenMinute(geoid: Egm96FifteenMinuteGeoid): TerrainGeoidModel;
+    /**
+     * Use the embedded EGM96 1-degree geoid grid for `h = H + N`.
+     */
+    static egm96OneDegree(): TerrainGeoidModel;
+    /**
+     * Model discriminator: `"egm96OneDegree"` or `"egm96FifteenMinute"`.
+     */
+    readonly kind: string;
+}
+
+/**
+ * Terrain store conversion, serialization, and parsing error variants.
+ */
+export enum TerrainStoreError {
+    /**
+     * File or directory I/O failed.
+     */
+    Io = 0,
+    /**
+     * DTED or terrain store bytes could not be parsed.
+     */
+    Parse = 1,
+    /**
+     * The terrain store version is not supported.
+     */
+    UnsupportedVersion = 2,
+    /**
+     * The terrain store datum tag is not supported.
+     */
+    UnsupportedDatum = 3,
+    /**
+     * Two input DTED files resolved to the same integer tile id.
+     */
+    DuplicateTile = 4,
+    /**
+     * A tile payload checksum did not match its index record.
+     */
+    Checksum = 5,
+}
+
+/**
+ * Metadata for one tile index record in a memory-mappable terrain store.
+ */
+export class TerrainStoreTileIndex {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * FNV-1a checksum of this tile's posting payload bytes.
+     */
+    readonly checksum64: bigint;
+    /**
+     * Byte length of this tile's posting payload in the store.
+     */
+    readonly dataLen: bigint;
+    /**
+     * Byte offset of this tile's posting payload in the store.
+     */
+    readonly dataOffset: bigint;
+    /**
+     * Number of latitude postings.
+     */
+    readonly latCount: number;
+    /**
+     * Integer latitude tile id, for example `36` for a tile covering
+     * `36..37` degrees.
+     */
+    readonly latIndex: number;
+    /**
+     * Number of longitude postings.
+     */
+    readonly lonCount: number;
+    /**
+     * Integer longitude tile id, for example `-107` for a tile covering
+     * `-107..-106` degrees.
+     */
+    readonly lonIndex: number;
+    /**
+     * Northern edge latitude, degrees.
+     */
+    readonly maxLatitudeDeg: number;
+    /**
+     * Eastern edge longitude, degrees.
+     */
+    readonly maxLongitudeDeg: number;
+    /**
+     * Southern edge latitude, degrees.
+     */
+    readonly minLatitudeDeg: number;
+    /**
+     * Western edge longitude, degrees.
+     */
+    readonly minLongitudeDeg: number;
+    /**
+     * Vertical datum for this tile's orthometric posting payload.
+     */
+    readonly verticalDatum: VerticalDatum;
+}
+
 /**
  * A named time scale. The JS value matches the variant order below.
  */
@@ -5555,6 +6109,16 @@ export class VelocitySolution {
     readonly velocityMS: Float64Array;
 }
 
+/**
+ * Vertical datum carried by a terrain store.
+ */
+export enum VerticalDatum {
+    /**
+     * Orthometric height `H` in metres above the EGM96 mean sea level geoid.
+     */
+    Egm96MslOrthometric = 0,
+}
+
 /**
  * Per-epoch topocentric visibility plus the dense pass list over the grid
  * window.
@@ -5678,6 +6242,50 @@ export class ZenithDelay {
  */
 export function acquire(samples: Float64Array, prn: bigint, options: any): AcquisitionResult;
 
+/**
+ * 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 }`.
+ */
+export function allanDeviation(series: any, tau0_s: number, averaging_factors: any): any;
+
+/**
+ * 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 }`.
+ */
+export function alphaBetaApplyMeasurement(predicted: any, measurement: number, dt: number, gains: any): any;
+
+/**
+ * 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 }`.
+ */
+export function alphaBetaFilterStep(state: any, measurement: number, dt: number, gains: any): any;
+
+/**
+ * Alpha-beta constant-rate prediction.
+ *
+ * `state` is `{ level, rate }` and `dt` is the positive propagation interval in
+ * seconds. Returns the predicted `{ level, rate }`.
+ */
+export function alphaBetaPredict(state: any, dt: number): any;
+
+/**
+ * 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`.
+ */
+export function alphaBetaSteadyStateGains(tracking_index: number): any;
+
 /**
  * On-sky angle in degrees between two direction vectors.
  */
@@ -5688,6 +6296,38 @@ export function angularSeparation(a: Float64Array, b: Float64Array): number;
  */
 export function angularSeparationCoords(a_lon_deg: number, a_lat_deg: number, b_lon_deg: number, b_lat_deg: number): number;
 
+/**
+ * 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.
+ */
+export function araim(geometry: any, ism: any, allocation: any): any;
+
+/**
+ * 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"`.
+ */
+export function araimFaultModes(geometry: any, ism: any, allocation: any): any;
+
+/**
+ * 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.
+ */
+export function araimLpv200Allocation(): any;
+
 /**
  * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
  *
@@ -5752,6 +6392,38 @@ export function carrierBandName(band: CarrierBand): string;
  */
 export function carrierFrequencyHz(system: GnssSystem, band: CarrierBand): number | undefined;
 
+/**
+ * CA-CFAR false alarm probability from searched-cell count, absolute
+ * threshold, and mean noise level.
+ */
+export function cfarCaFalseAlarmProbability(searched_cells: number, threshold: number, noise_level: number): number;
+
+/**
+ * CA-CFAR threshold multiplier from searched-cell count and target false alarm
+ * probability.
+ */
+export function cfarCaMultiplierFromPfa(searched_cells: number, false_alarm_probability: number): number;
+
+/**
+ * CA-CFAR false alarm probability from searched-cell count and multiplier.
+ */
+export function cfarCaPfaFromMultiplier(searched_cells: number, multiplier: number): number;
+
+/**
+ * CA-CFAR absolute threshold from searched-cell count, target false alarm
+ * probability, and mean noise level.
+ */
+export function cfarCaThreshold(searched_cells: number, false_alarm_probability: number, noise_level: number): number;
+
+/**
+ * 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.
+ */
+export function chanHoInitialGuess(sensors: any, arrival_times_s: any, propagation_speed_m_s: number, mode: any): any;
+
 /**
  * Returns `true` when a diff has any findings.
  */
@@ -5805,6 +6477,20 @@ export function coherentLossDb(freq_error_hz: number, integration_time_s: number
  */
 export function collisionProbability(object1: ConjunctionState, object2: ConjunctionState, hard_body_radius_km: number, method?: string | null): 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.
+ */
+export function computeAllanDeviations(input: any): any;
+
 /**
  * Coherently correlate interleaved IQ samples against a GPS C/A PRN replica.
  * `iq` is `[i0, q0, i1, q1, ...]`.
@@ -5902,6 +6588,14 @@ export function decodeRtcmMessage(body: Uint8Array): any;
  */
 export function decodeRtcmStream(bytes: Uint8Array): any;
 
+/**
+ * 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`.
+ */
 export function decodeSbasMessage(bytes: Uint8Array, form?: string | null): any;
 
 export function decodeSsr(bytes: Uint8Array, framed?: boolean | null): any;
@@ -5985,6 +6679,14 @@ export function dopplerShift(gcrs_position_km: Float64Array, gcrs_velocity_km_s:
  */
 export function dopplerToRangeRate(doppler_hz: number, carrier_hz: number): number;
 
+/**
+ * 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.
+ */
+export function dtedTreeToMmapStore(root: string): Uint8Array;
+
 /**
  * Angular radius in degrees of Earth as seen from each satellite position.
  */
@@ -6129,6 +6831,19 @@ export function estimateDecay(drag: DragForce, request: any): any;
  */
 export function estimateDecayWithSpaceWeather(drag: DragForce, table: SpaceWeatherTable, request: any): any;
 
+/**
+ * Exponentially weighted moving-average update.
+ *
+ * `alpha` must be in `[0, 1]`; the returned value is
+ * `previous + alpha * (sample - previous)`.
+ */
+export function ewmaUpdate(previous: number, sample: number, alpha: number): number;
+
+/**
+ * EWMA update with `alpha = 1 / 2^shift`.
+ */
+export function ewmaUpdatePowerOfTwo(previous: number, sample: number, shift: number): number;
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -6450,6 +7165,15 @@ export function gnssVisible(sp3: Sp3, station_ecef_m: Float64Array, j2000_second
  */
 export function gpsUtcOffsetS(year: number, month: number, day: number): number;
 
+/**
+ * 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 }`.
+ */
+export function hadamardDeviation(series: any, tau0_s: number, averaging_factors: any): any;
+
 /**
  * Trace of the Gauss-Newton Hessian approximation `J^T J`: the sum of the
  * squared column norms of the Jacobian, with no inverse formed.
@@ -6490,6 +7214,28 @@ export function iodGibbs(r1: Float64Array, r2: Float64Array, r3: Float64Array):
  */
 export function iodHerrickGibbs(r1: Float64Array, r2: Float64Array, r3: Float64Array, jd1: number, jd2: number, jd3: number): IodVelocity;
 
+/**
+ * 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`.
+ */
+export function ionexFromNodeSamples(samples: any, shell_height_km: number, base_radius_km: number, exponent: number): Ionex;
+
+/**
+ * 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`.
+ */
+export function ionexFromSamples(samples: any): Ionex;
+
 /**
  * Ionosphere-free code or meter-valued phase combination, metres.
  */
@@ -6539,6 +7285,15 @@ export function j2000SecondsToCivil(seconds: bigint): CivilDateTime;
  */
 export function jarqueBera(x: Float64Array): any;
 
+/**
+ * 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.
+ */
+export function kalmanCvSteadyStateGains(tracking_index: number, dt: number, measurement_variance: number): any;
+
 /**
  * GPS broadcast Klobuchar ionospheric group delay in the model's native units
  * (positive metres).
@@ -6751,12 +7506,38 @@ export function loadRinexObs(bytes: Uint8Array): RinexObs;
  */
 export function loadSp3(bytes: Uint8Array): Sp3;
 
+/**
+ * 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`.
+ */
+export function locateSource(sensors: any, arrival_times_s: any, propagation_speed_m_s: number, options: any): any;
+
 export function lunarSolarEclipses(start_unix_us: bigint, end_unix_us: bigint, step_s: number, tolerance_s: number): any;
 
 export function lunarSolarEclipsesSpk(spk: Spk, start_unix_us: bigint, end_unix_us: bigint, step_s: number, tolerance_s: number): any;
 
 export function lvlhRotation(position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
 
+/**
+ * Gaussian consistency factor applied by [`madSpread`].
+ */
+export function madGaussianConsistency(): number;
+
+/**
+ * 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`.
+ */
+export function madSpread(values: any, scale_floor: number): number;
+
 export function meanMotionCircular(radius_km: number): number;
 
 export function meanMotionFromState(position_km: Float64Array, velocity_km_s: Float64Array): number;
@@ -6799,6 +7580,15 @@ export function meridianTransits(body: string, station: any, start_unix_us: bigi
 
 export function meridianTransitsSpk(spk: Spk, body: string, station: any, start_unix_us: bigint, end_unix_us: bigint, step_s: number, tolerance_s: number): any;
 
+/**
+ * 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 }`.
+ */
+export function modifiedAdev(series: any, tau0_s: number, averaging_factors: any): any;
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -6881,6 +7671,28 @@ export function nequickGDelayM(_eval: any, frequency_hz: number): number;
  */
 export function nequickGStecTecu(_eval: any): number;
 
+/**
+ * Scalar normalized innovation squared statistic.
+ */
+export function nis(innovation: number, innovation_variance: number): number;
+
+/**
+ * Bar-Shalom expected NIS value for `dof` measurement degrees of freedom.
+ */
+export function nisExpectedValue(dof: number): number;
+
+/**
+ * Test a scalar innovation against a chi-square NIS gate.
+ *
+ * Returns `{ nis, threshold, inGate, dof }`, with `confidence` in `(0, 1)`.
+ */
+export function nisGate(innovation: number, innovation_variance: number, dof: number, confidence: number): any;
+
+/**
+ * Chi-square NIS gate threshold for `dof` and confidence probability.
+ */
+export function nisGateThreshold(dof: number, confidence: number): number;
+
 /**
  * Parse bytes and return grouped epoch snapshots directly.
  */
@@ -6911,11 +7723,26 @@ export function noiseAmplification(f1_hz: number, f2_hz: number): number;
  */
 export function normalCovariance(jacobian: Float64Array, m: number, n: number, variance_scale: number): Float64Array;
 
+/**
+ * Scalar normalized innovation `innovation / sqrt(innovationVariance)`.
+ */
+export function normalizedInnovation(innovation: number, innovation_variance: number): number;
+
 /**
  * Build the NTRIP connection request bytes for a config object.
  */
 export function ntripRequestBytes(config: any): Uint8Array;
 
+/**
+ * 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]`.
+ */
+export function observableStateMissingPositionEcefM(): any;
+
 /**
  * Predict observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -6974,6 +7801,15 @@ export function oceanTideLoading(station_ecef_m: Float64Array, year: number, mon
  */
 export function orthometricHeightM(ellipsoidal_height_m: number, lat_rad: number, lon_rad: number): number;
 
+/**
+ * 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 }`.
+ */
+export function overlappingAdev(series: any, tau0_s: number, averaging_factors: any): any;
+
 /**
  * Parallactic angle (degrees) of a target at a station.
  *
@@ -7365,6 +8201,12 @@ export function sampleBroadcastEphemeris(broadcast: BroadcastEphemeris, satellit
 
 export function sampleSp3Ephemeris(sp3: Sp3, satellites: string[], start_j2000_s: number, stop_j2000_s: number, step_s: number): any;
 
+/**
+ * Convert an SBAS satellite token such as `"S29"` to broadcast PRN number
+ * such as `129`. Returns `null` for non-SBAS satellites.
+ */
+export function satToSbasPrn(sat: string): any;
+
 /**
  * Apparent visual magnitude of a sunlit body from a diffuse-sphere phase law.
  *
@@ -7376,8 +8218,20 @@ export function sampleSp3Ephemeris(sp3: Sp3, satellites: string[], start_j2000_s
  */
 export function satelliteVisualMagnitude(range_km: number, phase_angle_deg: number, standard_magnitude: number, reference_range_km: number): number;
 
+/**
+ * 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.
+ */
 export function sbasCorrectedState(broadcast: BroadcastEphemeris, store: SbasCorrectionStore, geo: string, sat: string, t_j2000_s: number, mode?: string | null): any;
 
+/**
+ * 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.
+ */
+export function sbasPrnToSat(broadcast_prn: number): any;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -7592,6 +8446,13 @@ export function solveRtkFixed(config: any): RtkFixedSolution;
  */
 export function solveRtkFloat(config: any): RtkFloatSolution;
 
+/**
+ * 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.
+ */
 export function solveSppSbas(broadcast: BroadcastEphemeris, store: SbasCorrectionStore, geo: string, request: any, mode?: string | null): SppSolution;
 
 /**
@@ -7631,6 +8492,33 @@ export function solveVelocityBroadcast(broadcast: BroadcastEphemeris, observatio
  */
 export function solveWithFallback(precise: Sp3[], broadcast: BroadcastEphemeris, request: any, policy: any): SourcedSolution;
 
+/**
+ * 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.
+ */
+export function sourceCrlb(sensors: any, source_position_m: any, propagation_speed_m_s: number, timing_sigma_s: number): any;
+
+/**
+ * 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.
+ */
+export function sourceDop(sensors: any, source_position_m: any, propagation_speed_m_s: number): any;
+
+/**
+ * Return the plain mode object for TDOA solves against `referenceSensor`.
+ */
+export function sourceSolveModeTdoa(reference_sensor: number): any;
+
+/**
+ * Return the plain mode value for absolute time-of-arrival solves.
+ */
+export function sourceSolveModeToa(): string;
+
 /**
  * Extract a parsed SP3 product as the canonical precise-ephemeris samples, one
  * per real position record in ascending epoch order.
@@ -7738,6 +8626,20 @@ export function temeToGcrs(position_km: Float64Array, velocity_km_s: Float64Arra
  */
 export function terminatorLatitudeDeg(sub_solar_latitude_deg: number, sub_solar_longitude_deg: number, longitude_deg: number): number;
 
+/**
+ * Return an FNV-1a checksum for terrain store bytes.
+ */
+export function terrainStoreChecksum64(bytes: Uint8Array): bigint;
+
+/**
+ * Time deviation for explicit averaging factors.
+ *
+ * `series` is `{ kind, values }`, `tau0S` is seconds, and
+ * `averagingFactors` contains positive integer `m` values. Returns
+ * `{ tauS, deviation, n }`.
+ */
+export function timeDeviation(series: any, tau0_s: number, averaging_factors: any): any;
+
 /**
  * Short uppercase identifier for a time scale, e.g. `"GPST"`.
  */
@@ -7879,3 +8781,8 @@ export function wideLaneCycles(phi1_cycles: number, phi2_cycles: number, p1_m: n
  * Wide-lane wavelength `c / (f1 - f2)`, metres.
  */
 export function wideLaneWavelength(f1_hz: number, f2_hz: number): number;
+
+/**
+ * Convert a DTED tile tree and write canonical terrain store bytes to a path.
+ */
+export function writeDtedTreeToMmapStore(root: string, out_path: string): void;