@neilberkman/sidereon 0.8.0 → 0.9.0

package/pkg-node/sidereon.d.ts

@@ -145,6 +145,12 @@ export class Antex {
      * Return the satellite antenna for `prn` valid at `epoch`, or `undefined`.
      */
     satelliteAntenna(prn: string, epoch: AntexDateTime): Antenna | undefined;
+    /**
+     * Serialize to standard ANTEX 1.4 text. Deterministic: the same product
+     * always produces byte-identical text, and re-parsing the output yields an
+     * equal product.
+     */
+    toAntexString(): string;
     /**
      * Number of antenna blocks parsed from the product.
      */
@@ -210,6 +216,23 @@ export class AppliedCorrections {
     readonly dropped: string[];
 }
 
+/**
+ * Total mass density and temperature at altitude from NRLMSISE-00.
+ */
+export class AtmosphereDensity {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Total mass density, kilograms per cubic metre.
+     */
+    readonly densityKgM3: number;
+    /**
+     * Temperature at the requested altitude, kelvin.
+     */
+    readonly temperatureK: number;
+}
+
 /**
  * A parsed broadcast ephemeris store from a RINEX NAV file. `records` are the
  * usable GPS/Galileo/BeiDou records selected by the core default SPP policy.
@@ -230,6 +253,23 @@ export class BroadcastEphemeris {
      * fields are `null` where no compared epoch populated them.
      */
     compareToSp3(precise: Sp3, satellites: string[], from_j2000_s: number, to_j2000_s: number, step_s: number): any;
+    /**
+     * Compare this broadcast product against a precise SP3 product over a regular
+     * sampling window, letting the core window driver build the per-epoch grid.
+     *
+     * The window-form sibling of [`compareToSp3`]: instead of building the
+     * per-epoch keys here, this hands the core
+     * `sidereon_core::broadcast_comparison::compare_window` a `CompareWindow`
+     * (the inclusive `[fromJ2000S, toJ2000S]` broadcast span, the precise split
+     * Julian-date anchor for the window start, the `stepS` sampling step, and the
+     * velocity finite-difference half step) so the grid sampling, the final snap
+     * to the window end, and the lockstep precise-date advance all run in core.
+     * The precise anchor is derived from `fromJ2000S` (both products share GPS
+     * system time, as in [`compareToSp3`]), and `velocityHalfS` defaults to
+     * `round(stepS / 2)`. Returns the same `{ overall, perSatellite, missing }`
+     * report shape.
+     */
+    compareWindowToSp3(precise: Sp3, satellites: string[], from_j2000_s: number, to_j2000_s: number, step_s: number, velocity_half_s?: number | null): any;
     /**
      * Solve a receiver position from broadcast ephemeris ALONE: the supported
      * real-time / offline single-point-positioning mode. `request` is the same
@@ -237,6 +277,14 @@ export class BroadcastEphemeris {
      * solving against this broadcast store as an ephemeris source.
      */
     solveBroadcast(request: any): SppSolution;
+    /**
+     * Serialize the usable GPS, Galileo, and BeiDou broadcast records to
+     * standard RINEX 3 navigation text. Deterministic: the same record set
+     * always produces byte-identical text, and re-parsing the output yields the
+     * same records. GLONASS state-vector records are not part of the Keplerian
+     * broadcast-orbit grammar this writer emits and are therefore not included.
+     */
+    toRinexString(): string;
     /**
      * Number of usable GLONASS records.
      */
@@ -577,23 +625,62 @@ export class CdmObject {
     [Symbol.dispose](): void;
     /**
      * Build a CDM object. `positionKm` / `velocityKmS` are length-3
-     * `Float64Array`s; `covarianceRtn` is the length-6 RTN lower triangle
-     * `[CR_R, CT_R, CT_T, CN_R, CN_T, CN_N]`. `meta` carries the optional
-     * string fields.
+     * `Float64Array`s; `covarianceRtn` is the length-6 RTN position lower triangle
+     * `[CR_R, CT_R, CT_T, CN_R, CN_T, CN_N]`. `meta` carries the optional CCSDS
+     * metadata block (`objectDesignator`, `catalogName`, `objectName`,
+     * `internationalDesignator`, `objectType`, `operatorContactPosition`,
+     * `operatorOrganization`, `operatorPhone`, `operatorEmail`, `ephemerisName`,
+     * `covarianceMethod`, `maneuverable`, `orbitCenter`, `refFrame`,
+     * `gravityModel`, `atmosphericModel`, `nBodyPerturbations`,
+     * `solarRadPressure`, `earthTides`, `intrackThrust`) and the optional
+     * `velocityCovarianceRtn`, a length-15 `Float64Array` of the RTN
+     * velocity-covariance rows that complete the 6x6 matrix.
      */
     constructor(position_km: Float64Array, velocity_km_s: Float64Array, covariance_rtn: Float64Array, meta: any);
+    /**
+     * Atmospheric model.
+     */
+    readonly atmosphericModel: string | undefined;
     /**
      * Catalog name.
      */
     readonly catalogName: string | undefined;
+    /**
+     * Covariance method.
+     */
+    readonly covarianceMethod: string | undefined;
     /**
      * RTN position-covariance lower triangle, length-6 `Float64Array`.
      */
     readonly covarianceRtn: Float64Array;
+    /**
+     * Earth-tides indicator.
+     */
+    readonly earthTides: string | undefined;
+    /**
+     * Ephemeris name.
+     */
+    readonly ephemerisName: string | undefined;
+    /**
+     * Gravity model.
+     */
+    readonly gravityModel: string | undefined;
     /**
      * International designator (COSPAR ID).
      */
     readonly internationalDesignator: string | undefined;
+    /**
+     * In-track-thrust indicator.
+     */
+    readonly intrackThrust: string | undefined;
+    /**
+     * Maneuverability indicator.
+     */
+    readonly maneuverable: string | undefined;
+    /**
+     * N-body perturbations indicator.
+     */
+    readonly nBodyPerturbations: string | undefined;
     /**
      * Object designator.
      */
@@ -606,6 +693,26 @@ export class CdmObject {
      * Object type.
      */
     readonly objectType: string | undefined;
+    /**
+     * Operator contact position.
+     */
+    readonly operatorContactPosition: string | undefined;
+    /**
+     * Operator email.
+     */
+    readonly operatorEmail: string | undefined;
+    /**
+     * Operator organization.
+     */
+    readonly operatorOrganization: string | undefined;
+    /**
+     * Operator phone.
+     */
+    readonly operatorPhone: string | undefined;
+    /**
+     * Orbit center.
+     */
+    readonly orbitCenter: string | undefined;
     /**
      * Position vector, kilometres, length-3 `Float64Array`.
      */
@@ -614,6 +721,16 @@ export class CdmObject {
      * Reference frame.
      */
     readonly refFrame: string | undefined;
+    /**
+     * Solar-radiation-pressure indicator.
+     */
+    readonly solarRadPressure: string | undefined;
+    /**
+     * RTN velocity-covariance rows completing the 6x6 matrix, a length-15
+     * `Float64Array` in CCSDS order (`CRDOT_R` .. `CNDOT_NDOT`), or `undefined`
+     * when the producer carried only the position covariance block.
+     */
+    readonly velocityCovarianceRtn: Float64Array | undefined;
     /**
      * Velocity vector, km/s, length-3 `Float64Array`.
      */
@@ -643,6 +760,39 @@ export class ChecksumWarning {
     readonly lineLabel: string;
 }
 
+/**
+ * Civil calendar fields from a no-leap core time conversion.
+ */
+export class CivilDateTime {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Civil day of month.
+     */
+    readonly day: bigint;
+    /**
+     * Civil hour of day.
+     */
+    readonly hour: bigint;
+    /**
+     * Civil minute of hour.
+     */
+    readonly minute: bigint;
+    /**
+     * Civil month, 1-12.
+     */
+    readonly month: bigint;
+    /**
+     * Whole civil second of minute.
+     */
+    readonly second: bigint;
+    /**
+     * Civil year.
+     */
+    readonly year: bigint;
+}
+
 /**
  * A civil GPS-time epoch for RINEX clock interpolation. Calendar fields are
  * interpreted in GPS time; `gpsSeconds` is seconds since 1980-01-06 GPST.
@@ -762,6 +912,90 @@ export class ConjunctionState {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * A built-once constellation of already-initialized SGP4 satellites for repeated
+ * batch operations.
+ *
+ * Build it once from parsed [`Tle`]s, then call [`Constellation.propagate`] (and
+ * `visible` / `lookAngleArcs` / `groundTracks` / `passes`) as often as you like:
+ * it OWNS its satellites and BORROWS them on each call, so unlike the free
+ * [`propagateBatch`] (which consumes the `Tle` handles it is given) the same
+ * `Constellation` drives a live scene across frames with no re-parse and no
+ * per-frame handle churn. This is the JS form of Elixir's `Sidereon.Constellation`.
+ *
+ * It does no parsing or I/O: TLE text becomes satellites at the interface
+ * boundary ([`Tle`] / [`parseTleFile`]); the constellation only batches the core
+ * geometry over the satellites it was handed.
+ */
+export class Constellation {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Sub-satellite WGS84 ground tracks for every satellite over a shared epoch
+     * grid, in fleet order (element `i` is satellite `i`'s track), each reduced
+     * TEME->GCRS->ITRS->geodetic by the engine's validated transforms. A satellite
+     * that fails yields an empty track, keeping the result index-aligned. The
+     * batched form of [`Tle.groundTrack`].
+     */
+    groundTracks(epochs_unix_us: BigInt64Array): GroundTrack[];
+    /**
+     * Topocentric az/el/range arcs from `station` for every satellite over a
+     * shared epoch grid, in fleet order (element `i` is satellite `i`'s arc). A
+     * satellite that fails to propagate yields an empty arc, so the result stays
+     * index-aligned with the constellation. The batched form of [`Tle.lookAngles`].
+     */
+    lookAngleArcs(station: GroundStation, epochs_unix_us: BigInt64Array): LookAngles[];
+    /**
+     * Build a constellation from already-parsed [`Tle`]s, taking ownership of
+     * them. Each `Tle` keeps the opsmode it was constructed with, and its NORAD
+     * catalog number becomes the satellite's id in `visible`. The input order is
+     * the fleet order (the leading axis of every batch result and the
+     * `satelliteIndex` of every pass). The `Tle` handles are consumed; clone first
+     * (`tle.clone()`) to keep a per-satellite handle.
+     */
+    constructor(satellites: Tle[]);
+    /**
+     * Passes over `station` within `[startUnixUs, endUnixUs)` for every satellite,
+     * flattened across the constellation: each [`FleetPass`] carries the
+     * `satelliteIndex` (fleet-order) it belongs to. `elevationMaskDeg` defaults to
+     * 0, `stepSeconds` to 30, `timeToleranceS` to 1e-3. A satellite that fails to
+     * scan contributes no passes. Throws a `RangeError` on a non-positive step or
+     * an end at or before the start.
+     */
+    passes(station: GroundStation, start_unix_us: bigint, end_unix_us: bigint, elevation_mask_deg?: number | null, step_seconds?: number | null, time_tolerance_s?: number | null): FleetPass[];
+    /**
+     * Propagate the whole constellation over a shared epoch grid in one call,
+     * borrowing it (NOT consumed, so the same `Constellation` drives every frame).
+     *
+     * `epochsUnixUs` is a `BigInt64Array` of unix-microsecond UTC epochs shared
+     * by every satellite. Element `(i, j)` of the result is satellite `i`
+     * propagated to epoch `j`, bit-for-bit identical to the per-satellite
+     * [`Tle.propagate`] path. A satellite that fails to propagate yields `NaN`
+     * for all of its epochs, keeping the result index-aligned (mirroring Elixir's
+     * `propagate_all`, which surfaces per-satellite outcomes rather than failing
+     * the whole batch). An empty constellation or empty epoch grid yields empty
+     * arrays.
+     */
+    propagate(epochs_unix_us: BigInt64Array): FleetPropagation;
+    /**
+     * Satellites above `minElevationDeg` from `station` at a single epoch, each
+     * with its catalog number and topocentric az/el/range, sorted by elevation
+     * (highest first). The constellation form of the core `visibleFromSatellites`
+     * (Elixir `Constellation.visible_from`). Throws on an invalid station or
+     * elevation threshold.
+     */
+    visible(station: GroundStation, epoch_unix_us: bigint, min_elevation_deg: number): VisibleSatellite[];
+    /**
+     * The satellites' NORAD catalog numbers, in fleet order.
+     */
+    readonly catalogNumbers: string[];
+    /**
+     * Number of satellites in the constellation (the leading axis of every batch
+     * result).
+     */
+    readonly satelliteCount: number;
+}
+
 /**
  * Coherent GPS C/A correlation result.
  */
@@ -783,6 +1017,49 @@ export class CorrelationResult {
     readonly q: number;
 }
 
+/**
+ * A computed look-angle grid for a set of satellites and ground stations at one
+ * epoch. Build with [`coverageLookAngles`].
+ */
+export class CoverageGrid {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of visible satellites per station at `minElevationDeg`, as a flat
+     * array of length `stationCount`. Delegates to
+     * `sidereon_core::astro::coverage::access_counts`.
+     */
+    accessCounts(min_elevation_deg: number): Uint32Array;
+    /**
+     * The look angle for one satellite/station pair as `[azimuthDeg,
+     * elevationDeg, rangeKm]`, or `undefined` when that cell failed (the
+     * satellite was below the horizon geometry the kernel rejects) or the
+     * indices are out of range.
+     */
+    lookAngle(satellite_index: number, station_index: number): Float64Array | undefined;
+    /**
+     * Maximum successful elevation per station, degrees, as a flat array of
+     * length `stationCount`. A station with no successful cell reports `NaN`.
+     * Delegates to `sidereon_core::astro::coverage::max_elevation`.
+     */
+    maxElevationDeg(): Float64Array;
+    /**
+     * Row-major `[satellite][station]` visibility mask at `minElevationDeg`, as a
+     * flat `Uint8Array` of `1` (visible) / `0`. Error cells are not visible.
+     * Delegates to `sidereon_core::astro::coverage::visible_mask`.
+     */
+    visibleMask(min_elevation_deg: number): Uint8Array;
+    /**
+     * Number of satellites (grid rows).
+     */
+    readonly satelliteCount: number;
+    /**
+     * Number of ground stations (grid columns).
+     */
+    readonly stationCount: number;
+}
+
 /**
  * A DGNSS rover solve: the corrected SPP solution plus the base-relative
  * baseline.
@@ -860,6 +1137,50 @@ export class Dop {
      * Position DOP.
      */
     readonly pdop: number;
+    /**
+     * Per-clock-column time DOP: entry `i` is the cofactor standard deviation
+     * of the `i`-th clock state, indexed by clock column rather than tagged by
+     * constellation. The geometry-only `dop` path (`fromAzEl`,
+     * `fromLineOfSight`, `gnssDop`) carries no constellation context, so it
+     * leaves this **empty**; read the lone clock's value off [`tdop`](Self::tdop).
+     * Per-system entries are only populated on the multi-clock SPP path; pair
+     * them with that solve's system ordering via `SppSolution.systemTdops`.
+     */
+    readonly systemTdops: Float64Array;
+    /**
+     * Time DOP.
+     */
+    readonly tdop: number;
+    /**
+     * Vertical DOP.
+     */
+    readonly vdop: number;
+}
+
+/**
+ * Exact DOP at one epoch: the scalars plus the satellites that contributed
+ * rows, from `gnssDopAtEpoch`.
+ */
+export class DopGeometry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Geometric DOP.
+     */
+    readonly gdop: number;
+    /**
+     * Horizontal DOP.
+     */
+    readonly hdop: number;
+    /**
+     * Position DOP.
+     */
+    readonly pdop: number;
+    /**
+     * Satellite tokens that contributed line-of-sight rows.
+     */
+    readonly satellites: string[];
     /**
      * Time DOP.
      */
@@ -920,6 +1241,64 @@ export class DopSeries {
     readonly vdop: Float64Array;
 }
 
+/**
+ * One sampled exact-DOP point over a uniform window, from `gnssDopSeriesWindow`.
+ */
+export class DopSeriesSample {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Geometric DOP.
+     */
+    readonly gdop: number;
+    /**
+     * Horizontal DOP.
+     */
+    readonly hdop: number;
+    /**
+     * Position DOP.
+     */
+    readonly pdop: number;
+    /**
+     * Satellite tokens that contributed rows at this sample.
+     */
+    readonly satellites: string[];
+    /**
+     * Zero-based sample index from the window start.
+     */
+    readonly stepIndex: number;
+    /**
+     * Time DOP.
+     */
+    readonly tdop: number;
+    /**
+     * Vertical DOP.
+     */
+    readonly vdop: number;
+}
+
+/**
+ * Range-rate and Doppler result for a carrier frequency.
+ */
+export class DopplerShift {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Carrier Doppler shift, hertz; positive means a frequency increase.
+     */
+    readonly dopplerHz: number;
+    /**
+     * Dimensionless Doppler ratio; positive means approaching the station.
+     */
+    readonly dopplerRatio: number;
+    /**
+     * Range rate, kilometres per second; positive means receding.
+     */
+    readonly rangeRateKmS: number;
+}
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -1027,79 +1406,234 @@ export class FdeSolution {
 }
 
 /**
- * A batch of transformed states from [`temeToGcrs`]: flat row-major
- * `positionKm` and `velocityKmS` `Float64Array`s, each length `3 * epochCount`.
+ * One pass in a [`Constellation.passes`] result: the pass geometry plus the
+ * fleet-order `satelliteIndex` of the satellite it belongs to (map that index to
+ * your own per-satellite metadata).
  */
-export class FrameStates {
+export class FleetPass {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Number of states in the batch.
+     * AOS (acquisition of signal), unix microseconds.
      */
-    readonly epochCount: number;
+    readonly aosUnixUs: bigint;
     /**
-     * Transformed positions, kilometres, flat row-major `(n, 3)`.
+     * Culmination (peak elevation) time, unix microseconds.
      */
-    readonly positionKm: Float64Array;
+    readonly culminationUnixUs: bigint;
     /**
-     * Transformed velocities, km/s, flat row-major `(n, 3)`.
+     * LOS (loss of signal), unix microseconds.
      */
-    readonly velocityKmS: Float64Array;
+    readonly losUnixUs: bigint;
+    /**
+     * Peak elevation during the pass, degrees.
+     */
+    readonly maxElevationDeg: number;
+    /**
+     * Fleet-order index of the satellite this pass belongs to.
+     */
+    readonly satelliteIndex: number;
 }
 
 /**
- * One GLONASS broadcast state-vector record. `toeUtcJ2000S` is UTC seconds past
- * J2000; position is PZ-90.11 ECEF metres, velocity m/s, acceleration m/s^2.
+ * TEME states from a batched fleet SGP4 propagation. Each array is flat
+ * row-major with shape `(satelliteCount, epochCount, 3)`: satellite `i`'s arc
+ * occupies the contiguous slice `[i * epochCount * 3 .. (i + 1) * epochCount *
+ * 3]`, and within it epoch `j` is `[.. j * 3 + 3]`. Satellite `i`'s arc equals
+ * the [`TlePropagation`] from `satellites[i].propagate(epochsUnixUs)`.
  */
-export class GlonassRecordJs {
+export class FleetPropagation {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Lunisolar acceleration `[ax, ay, az]`, metres per second squared.
-     */
-    readonly accelerationMS2: Float64Array;
-    /**
-     * Broadcast clock bias, seconds.
-     */
-    readonly clockBiasS: number;
-    /**
-     * FDMA frequency-channel number.
+     * Number of epochs each satellite was propagated to (the second axis).
      */
-    readonly freqChannel: number;
+    readonly epochCount: number;
     /**
-     * Relative frequency offset.
+     * TEME positions, km, flat row-major `(satelliteCount, epochCount, 3)`,
+     * length `3 * satelliteCount * epochCount`.
      */
-    readonly gammaN: number;
+    readonly positionKm: Float64Array;
     /**
-     * PZ-90.11 ECEF position `[x, y, z]`, metres.
+     * Number of satellites in the fleet (the leading axis).
      */
-    readonly positionM: Float64Array;
+    readonly satelliteCount: number;
     /**
-     * RINEX satellite token such as `"R10"`.
+     * TEME velocities, km/s, flat row-major `(satelliteCount, epochCount, 3)`,
+     * length `3 * satelliteCount * epochCount`.
      */
-    readonly satellite: string;
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * A forgiving RTCM 3 stream scanner: slides over a byte buffer, resynchronizes
+ * on the next `0xD3` preamble whenever the length overruns or the CRC fails, and
+ * yields only frames whose CRC verifies, exactly as a receiver locks onto a
+ * serial feed.
+ *
+ * Wraps `sidereon_core::rtcm::FrameScanner`: construction runs the scan to
+ * completion (the core iterator owns the scanning logic) and `next()` walks the
+ * yielded frames.
+ */
+export class FrameScanner {
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * Satellite health; 0 is healthy.
+     * Begin scanning `bytes` from the start.
      */
-    readonly svHealth: number;
+    constructor(bytes: Uint8Array);
     /**
-     * Reference epoch, UTC seconds past J2000.
+     * The next CRC-valid frame as `{ body, frameLen }` (`body` a `Uint8Array`,
+     * the message body between the length word and the CRC), or `undefined` when
+     * the scan is exhausted.
      */
-    readonly toeUtcJ2000S: number;
+    next(): any;
     /**
-     * PZ-90.11 ECEF velocity `[vx, vy, vz]`, metres per second.
+     * The total number of CRC-valid frames the scan found.
      */
-    readonly velocityMS: Float64Array;
+    readonly length: number;
 }
 
 /**
- * A GNSS constellation. The JS value matches the variant order below.
+ * A batch of transformed states from [`temeToGcrs`]: flat row-major
+ * `positionKm` and `velocityKmS` `Float64Array`s, each length `3 * epochCount`.
  */
-export enum GnssSystem {
+export class FrameStates {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * GPS, RINEX letter `G`.
+     * Number of states in the batch.
+     */
+    readonly epochCount: number;
+    /**
+     * Transformed positions, kilometres, flat row-major `(n, 3)`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Transformed velocities, km/s, flat row-major `(n, 3)`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * A regular latitude/longitude grid of geoid undulation samples with bilinear
+ * interpolation, wrapping a real (loaded) geoid model.
+ */
+export class GeoidGrid {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Parse a grid from the documented whitespace-delimited text format (a
+     * six-field header `lat_min lon_min dlat dlon n_lat n_lon` followed by
+     * `n_lat * n_lon` samples in metres). Throws an `Error` on a malformed
+     * header or sample. Delegates to
+     * `sidereon_core::geoid::GeoidGrid::from_text`.
+     */
+    static fromText(text: string): GeoidGrid;
+    /**
+     * Build a grid from its origin, spacing, dimensions, and row-major samples
+     * (metres, latitude ascending outer, longitude ascending inner). Throws an
+     * `Error` when a dimension is zero, the sample count is not `nLat * nLon`, a
+     * spacing/origin is non-finite or a spacing is non-positive, or a sample is
+     * non-finite. Delegates to `sidereon_core::geoid::GeoidGrid::new`.
+     */
+    constructor(lat_min_deg: number, lon_min_deg: number, dlat_deg: number, dlon_deg: number, n_lat: number, n_lon: number, values_m: Float64Array);
+    /**
+     * Bilinearly interpolated undulation `N` (metres) at a geodetic position in
+     * degrees (latitude positive north, longitude positive east).
+     */
+    undulationDeg(lat_deg: number, lon_deg: number): number;
+    /**
+     * Bilinearly interpolated undulation `N` (metres) at a geodetic position in
+     * radians (latitude positive north, longitude positive east).
+     */
+    undulationRad(lat_rad: number, lon_rad: number): number;
+}
+
+/**
+ * One GLONASS broadcast state-vector record. `toeUtcJ2000S` is UTC seconds past
+ * J2000; position is PZ-90.11 ECEF metres, velocity m/s, acceleration m/s^2.
+ */
+export class GlonassRecordJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Lunisolar acceleration `[ax, ay, az]`, metres per second squared.
+     */
+    readonly accelerationMS2: Float64Array;
+    /**
+     * Broadcast clock bias, seconds.
+     */
+    readonly clockBiasS: number;
+    /**
+     * FDMA frequency-channel number.
+     */
+    readonly freqChannel: number;
+    /**
+     * Relative frequency offset.
+     */
+    readonly gammaN: number;
+    /**
+     * PZ-90.11 ECEF position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * RINEX satellite token such as `"R10"`.
+     */
+    readonly satellite: string;
+    /**
+     * Satellite health; 0 is healthy.
+     */
+    readonly svHealth: number;
+    /**
+     * Reference epoch, UTC seconds past J2000.
+     */
+    readonly toeUtcJ2000S: number;
+    /**
+     * PZ-90.11 ECEF velocity `[vx, vy, vz]`, metres per second.
+     */
+    readonly velocityMS: Float64Array;
+}
+
+/**
+ * One sampled rise/set/peak visibility pass, from `gnssPasses`.
+ */
+export class GnssPass {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Maximum sampled elevation in the pass, degrees.
+     */
+    readonly peakElevationDeg: number;
+    /**
+     * Zero-based sample index of the maximum sampled elevation.
+     */
+    readonly peakStepIndex: number;
+    /**
+     * Zero-based sample index of the first above-mask sample.
+     */
+    readonly riseStepIndex: number;
+    /**
+     * Satellite token, e.g. `"G05"`.
+     */
+    readonly satellite: string;
+    /**
+     * Zero-based sample index of the last above-mask sample.
+     */
+    readonly setStepIndex: number;
+}
+
+/**
+ * A GNSS constellation. The JS value matches the variant order below.
+ */
+export enum GnssSystem {
+    /**
+     * GPS, RINEX letter `G`.
      */
     Gps = 0,
     /**
@@ -1128,6 +1662,45 @@ export enum GnssSystem {
     Sbas = 6,
 }
 
+/**
+ * Per-epoch visible-satellite count over a sampled window, from
+ * `gnssVisibilitySeries`.
+ */
+export class GnssVisibilityCount {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of satellites visible at this sample.
+     */
+    readonly nVisible: number;
+    /**
+     * Zero-based sample index from the window start.
+     */
+    readonly stepIndex: number;
+}
+
+/**
+ * One satellite above the elevation mask at a single epoch, from `gnssVisible`.
+ */
+export class GnssVisibleSatellite {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Topocentric azimuth in `[0, 360)`, degrees.
+     */
+    readonly azimuthDeg: number;
+    /**
+     * Topocentric elevation, degrees.
+     */
+    readonly elevationDeg: number;
+    /**
+     * Satellite token, e.g. `"G05"`.
+     */
+    readonly satellite: string;
+}
+
 /**
  * A GNSS week number plus time-of-week, tagged by constellation.
  */
@@ -1177,6 +1750,34 @@ export class GroundStation {
     readonly longitudeDeg: number;
 }
 
+/**
+ * Sub-satellite ground-track points from a batched [`Tle.groundTrack`] call.
+ * Each array is a `Float64Array` of length `epochCount`, aligned to the input
+ * epoch grid. WGS84 geodetic: latitude/longitude in degrees, ellipsoidal height
+ * in kilometres.
+ */
+export class GroundTrack {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Ellipsoidal height above the WGS84 ellipsoid, kilometres.
+     */
+    readonly altKm: Float64Array;
+    /**
+     * Number of epochs evaluated.
+     */
+    readonly epochCount: number;
+    /**
+     * Geodetic latitude of the sub-satellite point, degrees north.
+     */
+    readonly latDeg: Float64Array;
+    /**
+     * Geodetic longitude of the sub-satellite point, degrees east in `[-180, 180]`.
+     */
+    readonly lonDeg: Float64Array;
+}
+
 /**
  * A point in time, tagged UTC, with the precise time scales resolved.
  *
@@ -1276,6 +1877,49 @@ export class Instant {
     readonly ut1JdSplit: JulianDate;
 }
 
+/**
+ * A determined orbit state: position and velocity at one epoch.
+ */
+export class IodState {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Position `[x, y, z]`, kilometres.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Velocity `[vx, vy, vz]`, kilometres per second.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * A Gibbs / Herrick-Gibbs velocity solve: the velocity at the middle position
+ * and the geometry diagnostics.
+ */
+export class IodVelocity {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Coplanarity angle of the three position vectors, radians.
+     */
+    readonly coplanarityRad: number;
+    /**
+     * Angle between the first and second position vectors, radians.
+     */
+    readonly theta12Rad: number;
+    /**
+     * Angle between the second and third position vectors, radians.
+     */
+    readonly theta23Rad: number;
+    /**
+     * Velocity at the middle position `[vx, vy, vz]`, kilometres per second.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
 /**
  * A parsed IONEX vertical-TEC product. Create with [`load_ionex`].
  */
@@ -1294,6 +1938,13 @@ 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;
+    /**
+     * Serialize to standard IONEX text. Deterministic: the same product always
+     * produces byte-identical text, and re-parsing the output yields an equal
+     * product (the canonical node axes, geometry, exponent, map epochs, and
+     * every TEC/RMS value).
+     */
+    toIonexString(): string;
     /**
      * Mean Earth radius used by the geometry, kilometres.
      */
@@ -1430,6 +2081,19 @@ export class JulianDate {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Build the no-leap civil UTC two-part Julian date for calendar fields.
+     *
+     * Delegates to `sidereon_core::astro::time::model::Instant::from_utc_civil`:
+     * `(year, month, day, hour, minute, second)` are marshalled through the
+     * engine's `split_julian_date`, tagged UTC, with no leap second applied
+     * (the civil convention the ionosphere / troposphere dispatchers consume).
+     * This is distinct from the leap-aware `Instant`, whose TT/UT1/TDB scales
+     * run the full UTC conversion. `second` may be fractional. Throws a
+     * `RangeError` on an out-of-day field whose residual leaves the one-day
+     * fraction window.
+     */
+    static fromUtcCivil(year: number, month: number, day: number, hour?: number | null, minute?: number | null, second?: number | null): JulianDate;
     /**
      * Residual day fraction relative to `whole`.
      */
@@ -1487,6 +2151,23 @@ export class KlobucharAlphaBetaJs {
     readonly beta: Float64Array;
 }
 
+/**
+ * The two transfer velocity vectors of a Lambert solution.
+ */
+export class LambertTransfer {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Transfer velocity at `r2` (arrival) `[vx, vy, vz]`, km/s.
+     */
+    readonly arrivalVelocityKmS: Float64Array;
+    /**
+     * Transfer velocity at `r1` (departure) `[vx, vy, vz]`, km/s.
+     */
+    readonly departureVelocityKmS: Float64Array;
+}
+
 /**
  * Provenance and coverage of the embedded IERS leap-second (TAI-UTC) table.
  */
@@ -1550,100 +2231,302 @@ export class LinkBudget {
 }
 
 /**
- * Topocentric look angles from a batched arc, each a `Float64Array` of length
- * `epochCount`.
+ * Decoded LNAV clock and ephemeris parameters (engineering units). Integer
+ * fields are recovered exactly; scaled fields are the transmitted integer times
+ * the IS-GPS-200 LSB. `l2_p_data_flag` is encode-only and not recovered.
  */
-export class LookAngles {
+export class LnavDecoded {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Azimuth, degrees clockwise from north.
+     * Clock bias coefficient, seconds.
      */
-    readonly azimuthDeg: Float64Array;
+    readonly af0: number;
     /**
-     * Elevation, degrees above the horizon.
+     * Clock drift coefficient, seconds per second.
      */
-    readonly elevationDeg: Float64Array;
+    readonly af1: number;
     /**
-     * Number of epochs evaluated.
+     * Clock drift-rate coefficient, seconds per second squared.
      */
-    readonly epochCount: number;
+    readonly af2: number;
     /**
-     * Slant range, kilometres.
+     * Age of data offset.
      */
-    readonly rangeKm: Float64Array;
-}
-
-/**
- * Niell hydrostatic and wet mapping factors, dimensionless.
- */
-export class MappingFactors {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
+    readonly aodo: number;
     /**
-     * Hydrostatic mapping factor (includes the height correction).
+     * Cosine harmonic correction to inclination, radians.
      */
-    readonly dry: number;
+    readonly cic: number;
     /**
-     * Wet mapping factor.
+     * Sine harmonic correction to inclination, radians.
      */
-    readonly wet: number;
-}
-
-/**
- * Which supported RINEX NAV message a broadcast record carries.
- */
-export enum NavMessage {
+    readonly cis: number;
     /**
-     * GPS legacy LNAV.
+     * Cosine harmonic correction to orbit radius, metres.
      */
-    GpsLnav = 0,
+    readonly crc: number;
     /**
-     * Galileo I/NAV.
+     * Sine harmonic correction to orbit radius, metres.
      */
-    GalileoInav = 1,
+    readonly crs: number;
     /**
-     * Galileo F/NAV.
+     * Cosine harmonic correction to argument of latitude, radians.
      */
-    GalileoFnav = 2,
+    readonly cuc: number;
     /**
-     * BeiDou D1.
+     * Sine harmonic correction to argument of latitude, radians.
      */
-    BeidouD1 = 3,
+    readonly cus: number;
     /**
-     * BeiDou D2.
+     * Mean motion difference, radians per second.
      */
-    BeidouD2 = 4,
-}
-
-/**
- * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
- */
-export class ObsEpoch {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
+    readonly deltaN: number;
     /**
-     * Civil epoch in the file time scale.
+     * Eccentricity.
      */
-    readonly epoch: ObsEpochTime;
+    readonly eccentricity: number;
     /**
-     * RINEX epoch flag. `0` is a normal observation epoch.
+     * Fit-interval flag.
      */
-    readonly flag: number;
+    readonly fitIntervalFlag: number;
     /**
-     * Number of satellites present at this epoch.
+     * Inclination at reference time, radians.
      */
-    readonly satelliteCount: number;
+    readonly i0: number;
     /**
-     * Satellite tokens present at this epoch.
+     * Rate of inclination, radians per second.
      */
-    readonly satellites: string[];
-}
-
-/**
+    readonly idot: number;
+    /**
+     * Issue of data, clock.
+     */
+    readonly iodc: number;
+    /**
+     * Issue of data, ephemeris.
+     */
+    readonly iode: number;
+    /**
+     * L2 code indicator.
+     */
+    readonly l2Code: number;
+    /**
+     * Mean anomaly at reference time, radians.
+     */
+    readonly m0: number;
+    /**
+     * Argument of perigee, radians.
+     */
+    readonly omega: number;
+    /**
+     * Longitude of ascending node at weekly epoch, radians.
+     */
+    readonly omega0: number;
+    /**
+     * Rate of right ascension, radians per second.
+     */
+    readonly omegaDot: number;
+    /**
+     * Square root of the semi-major axis, sqrt(metres).
+     */
+    readonly sqrtA: number;
+    /**
+     * SV health bits.
+     */
+    readonly svHealth: number;
+    /**
+     * Group delay differential, seconds.
+     */
+    readonly tgd: number;
+    /**
+     * Clock reference time, seconds.
+     */
+    readonly toc: number;
+    /**
+     * Ephemeris reference time, seconds.
+     */
+    readonly toe: number;
+    /**
+     * User range accuracy index.
+     */
+    readonly uraIndex: number;
+    /**
+     * GPS week number.
+     */
+    readonly weekNumber: number;
+}
+
+/**
+ * The three 300-bit LNAV subframes produced by [`lnavEncode`].
+ */
+export class LnavSubframes {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Subframe 1 (clock/health) as a 300-element `Uint8Array` of `0`/`1` bits.
+     */
+    readonly subframe1: Uint8Array;
+    /**
+     * Subframe 2 (ephemeris part 1) as a 300-element `Uint8Array`.
+     */
+    readonly subframe2: Uint8Array;
+    /**
+     * Subframe 3 (ephemeris part 2) as a 300-element `Uint8Array`.
+     */
+    readonly subframe3: Uint8Array;
+}
+
+/**
+ * Topocentric look angles from a batched arc, each a `Float64Array` of length
+ * `epochCount`.
+ */
+export class LookAngles {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Azimuth, degrees clockwise from north.
+     */
+    readonly azimuthDeg: Float64Array;
+    /**
+     * Elevation, degrees above the horizon.
+     */
+    readonly elevationDeg: Float64Array;
+    /**
+     * Number of epochs evaluated.
+     */
+    readonly epochCount: number;
+    /**
+     * Slant range, kilometres.
+     */
+    readonly rangeKm: Float64Array;
+}
+
+/**
+ * Niell hydrostatic and wet mapping factors, dimensionless.
+ */
+export class MappingFactors {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Hydrostatic mapping factor (includes the height correction).
+     */
+    readonly dry: number;
+    /**
+     * Wet mapping factor.
+     */
+    readonly wet: number;
+}
+
+/**
+ * One solved moving-baseline epoch.
+ */
+export class MovingBaselineSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Base receiver ECEF position (metres) used for this epoch, `[x, y, z]`.
+     */
+    readonly basePositionM: Float64Array;
+    /**
+     * Euclidean baseline length, metres.
+     */
+    readonly baselineLengthM: number;
+    /**
+     * Baseline vector `rover - base` (metres) in ECEF, `[dx, dy, dz]`. The
+     * integer-fixed baseline when `status` is `"Fixed"`, else the float baseline.
+     */
+    readonly baselineM: Float64Array;
+    /**
+     * The float baseline this epoch reduced through, `[dx, dy, dz]`, metres.
+     */
+    readonly floatBaselineM: Float64Array;
+    /**
+     * Whether the float baseline solve converged.
+     */
+    readonly floatConverged: boolean;
+    /**
+     * Integer ambiguity verdict for this epoch: `"Fixed"` or `"Float"`.
+     */
+    readonly status: string;
+}
+
+/**
+ * A named entry from a parsed TLE file: the satellite's name line (empty for a
+ * bare 2-line set) paired with its initialized [`Tle`].
+ */
+export class NamedTle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The satellite name from the preceding name line, with any CelesTrak `0 `
+     * marker stripped. Empty string for a bare 2-line element set.
+     */
+    readonly name: string;
+    /**
+     * The initialized two-line element set. Call `.propagate()` /
+     * `.lookAngles()` / `.findPasses()` on it directly.
+     */
+    readonly tle: Tle;
+}
+
+/**
+ * Which supported RINEX NAV message a broadcast record carries.
+ */
+export enum NavMessage {
+    /**
+     * GPS legacy LNAV.
+     */
+    GpsLnav = 0,
+    /**
+     * Galileo I/NAV.
+     */
+    GalileoInav = 1,
+    /**
+     * Galileo F/NAV.
+     */
+    GalileoFnav = 2,
+    /**
+     * BeiDou D1.
+     */
+    BeidouD1 = 3,
+    /**
+     * BeiDou D2.
+     */
+    BeidouD2 = 4,
+}
+
+/**
+ * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ */
+export class ObsEpoch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Civil epoch in the file time scale.
+     */
+    readonly epoch: ObsEpochTime;
+    /**
+     * RINEX epoch flag. `0` is a normal observation epoch.
+     */
+    readonly flag: number;
+    /**
+     * Number of satellites present at this epoch.
+     */
+    readonly satelliteCount: number;
+    /**
+     * Satellite tokens present at this epoch.
+     */
+    readonly satellites: string[];
+}
+
+/**
  * Civil epoch from a RINEX observation file, in the file time scale.
  */
 export class ObsEpochTime {
@@ -1837,118 +2720,305 @@ export class ObservationValueSeries {
 }
 
 /**
- * A canonical, format-agnostic CCSDS Orbit Mean-Elements Message.
+ * A canonical, format-agnostic CCSDS Orbit Ephemeris Message parsed from KVN or
+ * XML.
  */
-export class Omm {
+export class Oem {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Build an OMM. The eight leading arguments are required; `meta` carries the
-     * optional fields (`ccsdsOmmVers`, `creationDate`, ... `bstar`,
-     * `meanMotionDot`, `meanMotionDdot`).
-     */
-    constructor(epoch: OmmEpoch, mean_motion: number, eccentricity: number, inclination_deg: number, ra_of_asc_node_deg: number, arg_of_pericenter_deg: number, mean_anomaly_deg: number, norad_cat_id: number, meta: any);
-    /**
-     * Encode this OMM to CCSDS/CelesTrak JSON text.
+     * Build an OEM from one or more segments. `meta` carries the optional header
+     * fields (`ccsdsOemVers`, `creationDate`, `originator`).
      */
-    toJsonString(): string;
+    constructor(segments: OemSegment[], meta: any);
     /**
-     * Encode this OMM to CCSDS OMM KVN text.
+     * Encode this OEM to CCSDS OEM KVN text.
      */
     toKvnString(): string;
     /**
-     * Encode this OMM to CCSDS OMM XML text.
+     * Encode this OEM to CCSDS OEM XML text.
      */
     toXmlString(): string;
     /**
-     * Argument of pericenter, degrees.
+     * CCSDS OEM version string.
      */
-    readonly argOfPericenterDeg: number;
+    readonly ccsdsOemVers: string;
     /**
-     * B* drag term.
+     * Creation date.
      */
-    readonly bstar: number;
+    readonly creationDate: string | undefined;
     /**
-     * CCSDS OMM version string.
+     * Originator.
      */
-    readonly ccsdsOmmVers: string;
+    readonly originator: string | undefined;
     /**
-     * Center name.
+     * Number of segments.
      */
-    readonly centerName: string | undefined;
+    readonly segmentCount: number;
     /**
-     * Classification type.
+     * Metadata/data segments in message order.
      */
-    readonly classificationType: string;
+    readonly segments: OemSegment[];
     /**
-     * Creation date.
+     * Forgiving-parse count of ephemeris data lines skipped as malformed (KVN
+     * only; 0 for a constructed or XML-parsed message).
      */
-    readonly creationDate: string | undefined;
+    readonly skippedStates: number;
+}
+
+/**
+ * One OEM covariance block.
+ */
+export class OemCovariance {
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * Eccentricity.
+     * Build an OEM covariance block. `matrix` is a length-36 row-major
+     * `Float64Array` for the `[r, v]` state; it must be finite, symmetric, and
+     * positive semidefinite. `covRefFrame` is the optional frame label.
      */
-    readonly eccentricity: number;
+    constructor(epoch: string, matrix: Float64Array, cov_ref_frame?: string | null);
     /**
-     * Element set number.
+     * Covariance reference-frame label, or `undefined`.
      */
-    readonly elementSetNo: number;
+    readonly covRefFrame: string | undefined;
     /**
-     * SGP4 ephemeris type.
+     * Epoch text.
      */
-    readonly ephemerisType: number;
+    readonly epoch: string;
     /**
-     * The epoch.
+     * The 6x6 state covariance as a length-36 row-major `Float64Array`.
      */
-    readonly epoch: OmmEpoch;
+    readonly matrix: Float64Array;
+}
+
+/**
+ * OEM segment metadata: object identity, frame, time system, and span.
+ */
+export class OemMetadata {
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * Inclination, degrees.
+     * Build OEM segment metadata. The seven leading arguments are required;
+     * `meta` carries the optional fields (`useableStartTime`, `useableStopTime`,
+     * `interpolation`, `interpolationDegree`).
      */
-    readonly inclinationDeg: number;
+    constructor(object_name: string, object_id: string, center_name: string, ref_frame: string, time_system: string, start_time: string, stop_time: string, meta: any);
     /**
-     * Mean anomaly, degrees.
+     * Center name.
      */
-    readonly meanAnomalyDeg: number;
+    readonly centerName: string;
     /**
-     * Mean-element theory.
+     * Interpolation method label, or `undefined`.
      */
-    readonly meanElementTheory: string | undefined;
+    readonly interpolation: string | undefined;
     /**
-     * Mean motion, rev/day.
+     * Interpolation polynomial degree, or `undefined`.
      */
-    readonly meanMotion: number;
+    readonly interpolationDegree: number | undefined;
     /**
-     * Second derivative of mean motion.
+     * Object id (COSPAR international designator).
      */
-    readonly meanMotionDdot: number;
+    readonly objectId: string;
     /**
-     * First derivative of mean motion.
+     * Object name.
      */
-    readonly meanMotionDot: number;
+    readonly objectName: string;
     /**
-     * NORAD catalog number.
+     * Reference frame.
      */
-    readonly noradCatId: number;
+    readonly refFrame: string;
     /**
-     * Object id.
+     * Segment start time text.
      */
-    readonly objectId: string | undefined;
+    readonly startTime: string;
     /**
-     * Object name.
+     * Segment stop time text.
      */
-    readonly objectName: string | undefined;
+    readonly stopTime: string;
     /**
-     * Originator.
+     * Time system.
      */
-    readonly originator: string | undefined;
+    readonly timeSystem: string;
     /**
-     * Right ascension of the ascending node, degrees.
+     * Useable start time text, or `undefined`.
      */
-    readonly raOfAscNodeDeg: number;
+    readonly useableStartTime: string | undefined;
     /**
-     * Reference frame.
+     * Useable stop time text, or `undefined`.
      */
-    readonly refFrame: string | undefined;
-    /**
+    readonly useableStopTime: string | undefined;
+}
+
+/**
+ * One OEM metadata/data segment.
+ */
+export class OemSegment {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OEM segment from its metadata, state samples, and (possibly
+     * empty) covariance blocks.
+     */
+    constructor(metadata: OemMetadata, states: OemState[], covariances: OemCovariance[]);
+    /**
+     * Covariance blocks in segment order.
+     */
+    readonly covariances: OemCovariance[];
+    /**
+     * Segment metadata.
+     */
+    readonly metadata: OemMetadata;
+    /**
+     * State samples in segment order.
+     */
+    readonly states: OemState[];
+}
+
+/**
+ * One OEM Cartesian state sample.
+ */
+export class OemState {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OEM state sample. `epoch` is carried as text; `positionKm` and
+     * `velocityKmS` are length-3 `Float64Array`s. `accelerationKmS2` is an
+     * optional length-3 `Float64Array` (pass `undefined` for a position/velocity
+     * sample).
+     */
+    constructor(epoch: string, position_km: Float64Array, velocity_km_s: Float64Array, acceleration_km_s2?: Float64Array | null);
+    /**
+     * Acceleration vector, km/s^2, length-3 `Float64Array`, or `undefined`.
+     */
+    readonly accelerationKmS2: Float64Array | undefined;
+    /**
+     * Epoch text.
+     */
+    readonly epoch: string;
+    /**
+     * Position vector, kilometres, length-3 `Float64Array`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Velocity vector, km/s, length-3 `Float64Array`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * A canonical, format-agnostic CCSDS Orbit Mean-Elements Message.
+ */
+export class Omm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OMM. The eight leading arguments are required; `meta` carries the
+     * optional fields (`ccsdsOmmVers`, `creationDate`, ... `bstar`,
+     * `meanMotionDot`, `meanMotionDdot`).
+     */
+    constructor(epoch: OmmEpoch, mean_motion: number, eccentricity: number, inclination_deg: number, ra_of_asc_node_deg: number, arg_of_pericenter_deg: number, mean_anomaly_deg: number, norad_cat_id: number, meta: any);
+    /**
+     * Encode this OMM to CCSDS/CelesTrak JSON text.
+     */
+    toJsonString(): string;
+    /**
+     * Encode this OMM to CCSDS OMM KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Encode this OMM to CCSDS OMM XML text.
+     */
+    toXmlString(): string;
+    /**
+     * Argument of pericenter, degrees.
+     */
+    readonly argOfPericenterDeg: number;
+    /**
+     * B* drag term.
+     */
+    readonly bstar: number;
+    /**
+     * CCSDS OMM version string.
+     */
+    readonly ccsdsOmmVers: string;
+    /**
+     * Center name.
+     */
+    readonly centerName: string | undefined;
+    /**
+     * Classification type.
+     */
+    readonly classificationType: string;
+    /**
+     * Creation date.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Eccentricity.
+     */
+    readonly eccentricity: number;
+    /**
+     * Element set number.
+     */
+    readonly elementSetNo: number;
+    /**
+     * SGP4 ephemeris type.
+     */
+    readonly ephemerisType: number;
+    /**
+     * The epoch.
+     */
+    readonly epoch: OmmEpoch;
+    /**
+     * Inclination, degrees.
+     */
+    readonly inclinationDeg: number;
+    /**
+     * Mean anomaly, degrees.
+     */
+    readonly meanAnomalyDeg: number;
+    /**
+     * Mean-element theory.
+     */
+    readonly meanElementTheory: string | undefined;
+    /**
+     * Mean motion, rev/day.
+     */
+    readonly meanMotion: number;
+    /**
+     * Second derivative of mean motion.
+     */
+    readonly meanMotionDdot: number;
+    /**
+     * First derivative of mean motion.
+     */
+    readonly meanMotionDot: number;
+    /**
+     * NORAD catalog number.
+     */
+    readonly noradCatId: number;
+    /**
+     * Object id.
+     */
+    readonly objectId: string | undefined;
+    /**
+     * Object name.
+     */
+    readonly objectName: string | undefined;
+    /**
+     * Originator.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Right ascension of the ascending node, degrees.
+     */
+    readonly raOfAscNodeDeg: number;
+    /**
+     * Reference frame.
+     */
+    readonly refFrame: string | undefined;
+    /**
      * Revolution number at epoch.
      */
     readonly revAtEpoch: bigint;
@@ -2003,6 +3073,359 @@ export class OmmEpoch {
     readonly year: number;
 }
 
+/**
+ * A canonical, format-agnostic CCSDS Orbit Parameter Message parsed from KVN or
+ * XML.
+ */
+export class Opm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OPM from its blocks. `keplerian`, `spacecraft`, and `covariance`
+     * are optional (pass `undefined`); `maneuvers` is an array (possibly empty).
+     * `meta` carries the optional header fields (`ccsdsOpmVers`, `creationDate`,
+     * `originator`).
+     */
+    constructor(metadata: OpmMetadata, state: OpmState, keplerian: OpmKeplerian | null | undefined, spacecraft: OpmSpacecraft | null | undefined, covariance: OpmCovariance | null | undefined, maneuvers: OpmManeuver[], meta: any);
+    /**
+     * Encode this OPM to CCSDS OPM KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Encode this OPM to CCSDS OPM XML text.
+     */
+    toXmlString(): string;
+    /**
+     * CCSDS OPM version string.
+     */
+    readonly ccsdsOpmVers: string;
+    /**
+     * Covariance block, or `undefined`.
+     */
+    readonly covariance: OpmCovariance | undefined;
+    /**
+     * Creation date.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Keplerian-elements block, or `undefined`.
+     */
+    readonly keplerian: OpmKeplerian | undefined;
+    /**
+     * Maneuver blocks in message order.
+     */
+    readonly maneuvers: OpmManeuver[];
+    /**
+     * Metadata block.
+     */
+    readonly metadata: OpmMetadata;
+    /**
+     * Originator.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Spacecraft-parameters block, or `undefined`.
+     */
+    readonly spacecraft: OpmSpacecraft | undefined;
+    /**
+     * Cartesian state vector.
+     */
+    readonly state: OpmState;
+}
+
+/**
+ * Optional OPM 6x6 state covariance.
+ */
+export class OpmCovariance {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the covariance block. `matrix` is a length-36 row-major
+     * `Float64Array` for the `[r, v]` state; it must be finite, symmetric, and
+     * positive semidefinite. `covRefFrame` is the optional frame label.
+     */
+    constructor(matrix: Float64Array, cov_ref_frame?: string | null);
+    /**
+     * Covariance reference-frame label, or `undefined`.
+     */
+    readonly covRefFrame: string | undefined;
+    /**
+     * The 6x6 state covariance as a length-36 row-major `Float64Array`.
+     */
+    readonly matrix: Float64Array;
+}
+
+/**
+ * Optional OPM Keplerian-elements block.
+ */
+export class OpmKeplerian {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the Keplerian block. Supply exactly one of `trueAnomalyDeg` or
+     * `meanAnomalyDeg`; throws a `TypeError` if neither or both are given.
+     */
+    constructor(semi_major_axis_km: number, eccentricity: number, inclination_deg: number, ra_of_asc_node_deg: number, arg_of_pericenter_deg: number, gm_km3_s2: number, true_anomaly_deg?: number | null, mean_anomaly_deg?: number | null);
+    /**
+     * Argument of pericenter, degrees.
+     */
+    readonly argOfPericenterDeg: number;
+    /**
+     * Eccentricity.
+     */
+    readonly eccentricity: number;
+    /**
+     * Gravitational parameter, km^3/s^2.
+     */
+    readonly gmKm3S2: number;
+    /**
+     * Inclination, degrees.
+     */
+    readonly inclinationDeg: number;
+    /**
+     * Mean anomaly, degrees, or `undefined` when a true anomaly was supplied.
+     */
+    readonly meanAnomalyDeg: number | undefined;
+    /**
+     * Right ascension of the ascending node, degrees.
+     */
+    readonly raOfAscNodeDeg: number;
+    /**
+     * Semi-major axis, kilometres.
+     */
+    readonly semiMajorAxisKm: number;
+    /**
+     * True anomaly, degrees, or `undefined` when a mean anomaly was supplied.
+     */
+    readonly trueAnomalyDeg: number | undefined;
+}
+
+/**
+ * One OPM maneuver block. Every field is mandatory in CCSDS 502.0-B when a
+ * maneuver is present.
+ */
+export class OpmManeuver {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a maneuver block. `dvKmS` is a length-3 `Float64Array` of the
+     * delta-v in km/s.
+     */
+    constructor(epoch_ignition: string, duration_s: number, delta_mass_kg: number, ref_frame: string, dv_km_s: Float64Array);
+    /**
+     * Change in mass, kilograms.
+     */
+    readonly deltaMassKg: number;
+    /**
+     * Maneuver duration, seconds.
+     */
+    readonly durationS: number;
+    /**
+     * Delta-v vector, km/s, length-3 `Float64Array`.
+     */
+    readonly dvKmS: Float64Array;
+    /**
+     * Ignition epoch text.
+     */
+    readonly epochIgnition: string;
+    /**
+     * Maneuver reference frame.
+     */
+    readonly refFrame: string;
+}
+
+/**
+ * OPM metadata block: object identity, center, reference frame, and time system.
+ */
+export class OpmMetadata {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the OPM metadata block. Every field is mandatory in CCSDS 502.0-B.
+     */
+    constructor(object_name: string, object_id: string, center_name: string, ref_frame: string, time_system: string);
+    /**
+     * Center name.
+     */
+    readonly centerName: string;
+    /**
+     * Object id (COSPAR international designator).
+     */
+    readonly objectId: string;
+    /**
+     * Object name.
+     */
+    readonly objectName: string;
+    /**
+     * Reference frame.
+     */
+    readonly refFrame: string;
+    /**
+     * Time system.
+     */
+    readonly timeSystem: string;
+}
+
+/**
+ * Optional OPM spacecraft-parameters block. Every sub-field is individually
+ * optional.
+ */
+export class OpmSpacecraft {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the spacecraft-parameters block. Pass `undefined` for absent fields.
+     */
+    constructor(mass_kg?: number | null, solar_rad_area_m2?: number | null, solar_rad_coeff?: number | null, drag_area_m2?: number | null, drag_coeff?: number | null);
+    /**
+     * Drag area, square metres.
+     */
+    readonly dragAreaM2: number | undefined;
+    /**
+     * Drag coefficient.
+     */
+    readonly dragCoeff: number | undefined;
+    /**
+     * Mass, kilograms.
+     */
+    readonly massKg: number | undefined;
+    /**
+     * Solar-radiation-pressure area, square metres.
+     */
+    readonly solarRadAreaM2: number | undefined;
+    /**
+     * Solar-radiation-pressure coefficient.
+     */
+    readonly solarRadCoeff: number | undefined;
+}
+
+/**
+ * OPM Cartesian state vector at the message epoch.
+ */
+export class OpmState {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build the OPM state. `epoch` is carried as text; `positionKm` and
+     * `velocityKmS` are length-3 `Float64Array`s in kilometres and km/s.
+     */
+    constructor(epoch: string, position_km: Float64Array, velocity_km_s: Float64Array);
+    /**
+     * Epoch text.
+     */
+    readonly epoch: string;
+    /**
+     * Position vector, kilometres, length-3 `Float64Array`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Velocity vector, km/s, length-3 `Float64Array`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * The result of [`parseTleFile`]: the satellites that parsed, plus a count of
+ * complete records that were skipped because SGP4 initialization failed.
+ */
+export class ParsedTleFile {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of satellites that parsed (length of `satellites`).
+     */
+    readonly count: number;
+    /**
+     * The successfully parsed satellites, in file order, each as a `{ name, tle }`.
+     */
+    readonly satellites: NamedTle[];
+    /**
+     * How many complete `(line 1, line 2)` records were found but skipped
+     * because their element set failed SGP4 initialization.
+     */
+    readonly skipped: number;
+}
+
+/**
+ * A long span represented by contiguous independently-fitted reduced-orbit
+ * segments. Carries the fitted segments and the time scale they were fitted in;
+ * evaluate and drift queries reuse that scale.
+ */
+export class PiecewiseOrbit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate the piecewise model against `truth` ECEF samples, flagging the
+     * first epoch whose error exceeds `thresholdM`. Truth samples outside the
+     * model span are skipped. Delegates to
+     * `sidereon_core::orbit::piecewise_drift`.
+     */
+    drift(truth: any, threshold_m: number): ReducedOrbitDrift;
+    /**
+     * Sample an SP3 product and evaluate this piecewise model against those
+     * positions. Delegates to
+     * `sidereon_core::orbit::drift_piecewise_reduced_orbit_source`.
+     */
+    driftSp3(sp3: Sp3, satellite: string, options: any): ReducedOrbitDrift;
+    /**
+     * Sample a TLE/SGP4 source in UTC and evaluate this piecewise model against
+     * those positions. Delegates to
+     * `sidereon_core::orbit::drift_piecewise_reduced_orbit_source`.
+     */
+    driftTle(tle: Tle, options: any): ReducedOrbitDrift;
+    /**
+     * Evaluate the piecewise model position at `query` in `frame` (`"ecef"` or
+     * `"gcrs"`). Delegates to `sidereon_core::orbit::piecewise_position`.
+     */
+    position(query: any, frame: string): Float64Array;
+    /**
+     * Evaluate the piecewise model position and velocity at `query` in `frame`.
+     * Delegates to `sidereon_core::orbit::piecewise_position_velocity`.
+     */
+    positionVelocity(query: any, frame: string): ReducedOrbitState;
+    /**
+     * Zero-based index of the segment covering `query`. Delegates to
+     * `sidereon_core::orbit::select_piecewise_segment`. Throws an `Error` when
+     * the epoch is outside coverage.
+     */
+    segmentIndexAt(query: any): number;
+    /**
+     * Model label, `"circular_secular"` or `"eccentric_secular"`.
+     */
+    readonly model: string;
+    /**
+     * Number of contiguous fitted segments.
+     */
+    readonly segmentCount: number;
+    /**
+     * Rounded segment length used to tile the requested window, seconds.
+     */
+    readonly segmentSeconds: bigint;
+}
+
+/**
+ * Source-backed piecewise reduced-orbit fit result.
+ */
+export class PiecewiseOrbitSourceFit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The fitted piecewise reduced-orbit model.
+     */
+    readonly orbit: PiecewiseOrbit;
+    /**
+     * Number of samples requested from the source.
+     */
+    readonly requestedSamples: number;
+    /**
+     * Number of source samples used by all fitted segments.
+     */
+    readonly usedSamples: number;
+}
+
 /**
  * Static integer-fixed PPP solution.
  */
@@ -2077,6 +3500,60 @@ export class PppFloatSolution {
     readonly ztdResidualM: number | undefined;
 }
 
+/**
+ * Predicted GNSS observables for one satellite at one receive epoch. Every
+ * field is computed by `sidereon_core::observables::predict`.
+ */
+export class PredictedObservables {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Topocentric azimuth in `[0, 360)`, degrees.
+     */
+    readonly azimuthDeg: number;
+    /**
+     * Doppler shift at the option carrier frequency, hertz.
+     */
+    readonly dopplerHz: number;
+    /**
+     * Topocentric elevation, degrees.
+     */
+    readonly elevationDeg: number;
+    /**
+     * Geometric range after optional Sagnac rotation, metres.
+     */
+    readonly geometricRangeM: number;
+    /**
+     * Receiver-to-satellite line-of-sight unit vector in ECEF, `[x, y, z]`.
+     */
+    readonly losUnit: Float64Array;
+    /**
+     * Range-rate line-of-sight projection, metres per second.
+     */
+    readonly rangeRateMS: number;
+    /**
+     * Satellite clock offset at transmit time, seconds, or `undefined`.
+     */
+    readonly satClockS: number | undefined;
+    /**
+     * Sagnac-rotated satellite ECEF position, metres, `[x, y, z]`.
+     */
+    readonly satPosEcefM: Float64Array;
+    /**
+     * Sagnac-rotated satellite ECEF velocity, metres per second, `[vx, vy, vz]`.
+     */
+    readonly satVelocityMS: Float64Array;
+    /**
+     * Transmit-time offset from receive time, rounded to microseconds.
+     */
+    readonly transmitOffsetUs: bigint;
+    /**
+     * Transmit time as seconds since J2000.
+     */
+    readonly transmitTimeJ2000S: number;
+}
+
 /**
  * Reason a satellite was dropped from paired pseudorange combination.
  */
@@ -2100,57 +3577,187 @@ export enum PseudorangeDropReason {
 }
 
 /**
- * Flattened pseudorange rows from one RINEX OBS epoch. `satellites` is
- * row-aligned with `rangesM`; ranges are metres.
+ * Flattened pseudorange rows from one RINEX OBS epoch. `satellites` is
+ * row-aligned with `rangesM`; ranges are metres.
+ */
+export class PseudorangeSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of rows.
+     */
+    readonly length: number;
+    /**
+     * Pseudorange values, metres, as a `Float64Array`.
+     */
+    readonly rangesM: Float64Array;
+    /**
+     * Satellite tokens, row-aligned with `rangesM`.
+     */
+    readonly satellites: string[];
+}
+
+/**
+ * RAIM weighting mode: either unit weights or per-satellite inverse-variance
+ * weights (missing satellites default to unit weight).
+ */
+export class RaimWeights {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-satellite inverse-variance weights. `weights` must be positive and
+     * finite and the same length as `satelliteIds`. Throws a `TypeError` on a
+     * length mismatch and a `RangeError` on a non-positive weight.
+     */
+    static bySatellite(satellite_ids: string[], weights: Float64Array): RaimWeights;
+    /**
+     * Unit weights, equivalent to sigma = 1 m for every satellite.
+     */
+    static unit(): RaimWeights;
+    /**
+     * True when all satellites use unit weight.
+     */
+    readonly isUnit: boolean;
+    /**
+     * Satellite tokens for per-satellite weights, sorted by token.
+     */
+    readonly satelliteIds: string[];
+    /**
+     * Inverse-variance weights as a `Float64Array`, sorted by satellite token.
+     */
+    readonly weights: Float64Array;
+}
+
+/**
+ * A fitted compact reduced-orbit model. Carries the fitted elements and the
+ * time scale they were fitted in; evaluate and drift queries reuse that scale.
+ */
+export class ReducedOrbit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate the model against `truth` ECEF samples, flagging the first epoch
+     * whose error exceeds `thresholdM`. Delegates to
+     * `sidereon_core::orbit::drift`.
+     */
+    drift(truth: any, threshold_m: number): ReducedOrbitDrift;
+    /**
+     * Sample an SP3 product and evaluate this model against those positions.
+     * Delegates to `sidereon_core::orbit::drift_reduced_orbit_source`.
+     */
+    driftSp3(sp3: Sp3, satellite: string, options: any): ReducedOrbitDrift;
+    /**
+     * Sample a TLE/SGP4 source in UTC and evaluate this model against those
+     * positions. Delegates to
+     * `sidereon_core::orbit::drift_reduced_orbit_source`.
+     */
+    driftTle(tle: Tle, options: any): ReducedOrbitDrift;
+    /**
+     * Evaluate the model position at `query` in `frame` (`"ecef"` or
+     * `"gcrs"`). Delegates to `sidereon_core::orbit::position`.
+     */
+    position(query: any, frame: string): Float64Array;
+    /**
+     * Evaluate the model position and velocity at `query` in `frame`.
+     * Delegates to `sidereon_core::orbit::position_velocity`.
+     */
+    positionVelocity(query: any, frame: string): ReducedOrbitState;
+    /**
+     * Fitted mean elements as a `Float64Array`:
+     * `[a_m, e, i, raan, raanRate, raanRateJ2, argLat, n]` for the circular
+     * model, with `[h, k, argPerigee]` appended for the eccentric model.
+     */
+    readonly elements: Float64Array;
+    /**
+     * Fit residual maximum over the samples, metres.
+     */
+    readonly maxM: number;
+    /**
+     * Model label, `"circular_secular"` or `"eccentric_secular"`.
+     */
+    readonly model: string;
+    /**
+     * Number of samples used in the fit.
+     */
+    readonly nSamples: number;
+    /**
+     * Fit residual RMS over the samples, metres.
+     */
+    readonly rmsM: number;
+}
+
+/**
+ * Model-vs-truth drift report from `drift`.
+ */
+export class ReducedOrbitDrift {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-epoch position error magnitudes, metres, in input order.
+     */
+    readonly errorsM: Float64Array;
+    /**
+     * Maximum error over the horizon, metres.
+     */
+    readonly maxM: number;
+    /**
+     * Number of samples requested from the source or supplied by the caller.
+     */
+    readonly requestedSamples: number;
+    /**
+     * Root-mean-square error over the horizon, metres.
+     */
+    readonly rmsM: number;
+    /**
+     * Index of the first epoch whose error exceeds the threshold, or `-1`.
+     */
+    readonly thresholdIndex: bigint;
+    /**
+     * Number of samples evaluated in the drift report.
+     */
+    readonly usedSamples: number;
+}
+
+/**
+ * Source-backed reduced-orbit fit result.
  */
-export class PseudorangeSeries {
+export class ReducedOrbitSourceFit {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Number of rows.
+     * The fitted reduced-orbit model.
      */
-    readonly length: number;
+    readonly orbit: ReducedOrbit;
     /**
-     * Pseudorange values, metres, as a `Float64Array`.
+     * Number of samples requested from the source.
      */
-    readonly rangesM: Float64Array;
+    readonly requestedSamples: number;
     /**
-     * Satellite tokens, row-aligned with `rangesM`.
+     * Number of source samples used by the fit.
      */
-    readonly satellites: string[];
+    readonly usedSamples: number;
 }
 
 /**
- * RAIM weighting mode: either unit weights or per-satellite inverse-variance
- * weights (missing satellites default to unit weight).
+ * Receiver model position and velocity from `positionVelocity`.
  */
-export class RaimWeights {
+export class ReducedOrbitState {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Per-satellite inverse-variance weights. `weights` must be positive and
-     * finite and the same length as `satelliteIds`. Throws a `TypeError` on a
-     * length mismatch and a `RangeError` on a non-positive weight.
-     */
-    static bySatellite(satellite_ids: string[], weights: Float64Array): RaimWeights;
-    /**
-     * Unit weights, equivalent to sigma = 1 m for every satellite.
-     */
-    static unit(): RaimWeights;
-    /**
-     * True when all satellites use unit weight.
-     */
-    readonly isUnit: boolean;
-    /**
-     * Satellite tokens for per-satellite weights, sorted by token.
+     * Model position `[x, y, z]`, metres.
      */
-    readonly satelliteIds: string[];
+    readonly positionM: Float64Array;
     /**
-     * Inverse-variance weights as a `Float64Array`, sorted by satellite token.
+     * Model velocity `[vx, vy, vz]`, metres per second.
      */
-    readonly weights: Float64Array;
+    readonly velocityMS: Float64Array;
 }
 
 /**
@@ -2174,6 +3781,12 @@ export class RinexClock {
      * One satellite's clock series, or `undefined` if the satellite is absent.
      */
     seriesFor(satellite_id: string): ClockSeries | undefined;
+    /**
+     * Serialize to standard RINEX clock text. Deterministic: the same product
+     * always produces byte-identical text, and re-parsing the output reproduces
+     * the same time scale and per-satellite bias series.
+     */
+    toRinexString(): string;
     /**
      * Total number of parsed satellite clock samples.
      */
@@ -2219,6 +3832,12 @@ export class RinexObs {
      * Extract single-frequency pseudoranges for one epoch.
      */
     pseudoranges(epoch_index: number, policy?: SignalPolicy | null): PseudorangeSeries;
+    /**
+     * Serialize to standard RINEX 3 observation text. Deterministic: the same
+     * product always produces byte-identical text, and re-parsing the output
+     * reproduces the same header and epochs.
+     */
+    toRinexString(): string;
     /**
      * Number of parsed epoch records.
      */
@@ -2456,6 +4075,21 @@ export class Sp3 {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Return a copy of `other` with its clocks shifted onto this product's
+     * clock datum. Epochs without an offset estimate are left unchanged.
+     * Delegates to `sidereon_core::ephemeris::align_clock_reference`.
+     */
+    alignClockReference(other: Sp3, min_common?: number | null): Sp3;
+    /**
+     * Estimate `other`'s per-epoch common clock offset relative to this product.
+     *
+     * The result is one row per matched epoch with enough common clocked
+     * satellites. Subtract `offsetS` from `other` clocks to put them on this
+     * product's clock datum. Delegates to
+     * `sidereon_core::ephemeris::clock_reference_offset`.
+     */
+    clockReferenceOffset(other: Sp3, min_common?: number | null): Sp3ClockReferenceOffset[];
     /**
      * Compute DGNSS pseudorange corrections from a surveyed base station.
      *
@@ -2502,6 +4136,16 @@ export class Sp3 {
      * a `TypeError` for malformed input and an `Error` if the solve fails.
      */
     solveSpp(request: any): SppSolution;
+    /**
+     * Solve a batch of independent SPP epochs against this ephemeris in one call.
+     *
+     * `epochs` is an array of SPP request objects (the `SppRequest` shape) and
+     * `options` the shared `{ withGeodetic?, maxPdop?, coarseSearchSeeds? }`
+     * applied to every epoch. Returns an `SppBatchSolution` whose per-epoch
+     * results are index-aligned to `epochs`; each epoch independently converged
+     * or failed. Delegates to the serial reference batch kernel.
+     */
+    solveSppBatch(epochs: any, options: any): SppBatchSolution;
     /**
      * The exact parsed state of `satellite` at record `epochIndex` (no
      * interpolation). Throws a `RangeError` past the last epoch and a
@@ -2523,6 +4167,74 @@ export class Sp3 {
     readonly satellites: string[];
 }
 
+/**
+ * Per-(epoch, satellite) agreement statistics for one accepted merged cell:
+ * how tightly the consensus sources clustered about the combined value.
+ */
+export class Sp3AgreementMetric {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Largest absolute clock deviation from the combined clock, seconds;
+     * `undefined` when the cell carries no clock.
+     */
+    readonly clockMaxS: number | undefined;
+    /**
+     * Number of sources in the accepted clock consensus (0 when the cell
+     * carries no clock).
+     */
+    readonly clockMembers: number;
+    /**
+     * RMS of the consensus members' deviation from the combined clock, seconds;
+     * `undefined` when the cell carries no clock.
+     */
+    readonly clockRmsS: number | undefined;
+    /**
+     * Cell epoch as seconds since J2000 in the product time scale.
+     */
+    readonly epochJ2000Seconds: number;
+    /**
+     * Largest 3D distance of any consensus member from the combined position,
+     * metres.
+     */
+    readonly positionMaxM: number;
+    /**
+     * Number of sources in the accepted position consensus (>= 1).
+     */
+    readonly positionMembers: number;
+    /**
+     * RMS of the consensus members' 3D distance from the combined position,
+     * metres (zero for a single-source cell).
+     */
+    readonly positionRmsM: number;
+    /**
+     * Satellite token, e.g. `"G01"`.
+     */
+    readonly satellite: string;
+}
+
+/**
+ * One epoch's common clock offset between two SP3 products.
+ */
+export class Sp3ClockReferenceOffset {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Matched epoch as seconds since J2000 in the product time scale.
+     */
+    readonly epochJ2000Seconds: number;
+    /**
+     * `other - reference` clock datum, seconds.
+     */
+    readonly offsetS: number;
+    /**
+     * Number of satellites used in the median offset estimate.
+     */
+    readonly satellites: number;
+}
+
 /**
  * A batch of interpolated SP3 states.
  */
@@ -2574,6 +4286,13 @@ export class Sp3MergeReport {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Per-(epoch, satellite) agreement statistics for every accepted cell, in
+     * output (epoch, then satellite) order — one entry per cell written to the
+     * merged product.
+     */
+    readonly agreement: Sp3AgreementMetric[];
+    readonly agreementCount: number;
     readonly positionOutlierCount: number;
     /**
      * Cells where an accepted consensus rejected source outliers.
@@ -2672,6 +4391,29 @@ export class Sp3State {
     readonly velocityMS: Float64Array | undefined;
 }
 
+/**
+ * Canonical quiet-Sun space-weather indices for NRLMSISE-00, mirrored from the
+ * core so a JS caller can pass moderate-activity defaults to [`atmosphereDensity`]
+ * without re-deriving the magic numbers.
+ */
+export class SpaceWeatherDefaults {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Daily magnetic Ap index.
+     */
+    readonly ap: number;
+    /**
+     * Daily F10.7 solar radio flux.
+     */
+    readonly f107: number;
+    /**
+     * 81-day centred F10.7 average.
+     */
+    readonly f107a: number;
+}
+
 /**
  * A parsed in-memory JPL/NAIF SPK kernel.
  *
@@ -2790,6 +4532,38 @@ export class SpkState {
     readonly velocityKmS: Float64Array | undefined;
 }
 
+/**
+ * The per-epoch results of a batch SPP solve, index-aligned to the input epochs.
+ * Each epoch independently either converged to a solution or failed; query an
+ * epoch with [`SppBatchSolution.isOk`] / [`SppBatchSolution.solution`] /
+ * [`SppBatchSolution.error`].
+ */
+export class SppBatchSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The solve-failure message for epoch `index`, or `undefined` when the epoch
+     * converged. Throws a `RangeError` for an out-of-range index.
+     */
+    error(index: number): string | undefined;
+    /**
+     * Whether epoch `index` converged to a solution. Throws a `RangeError` for
+     * an out-of-range index.
+     */
+    isOk(index: number): boolean;
+    /**
+     * The solution for epoch `index`. Throws a `RangeError` for an out-of-range
+     * index and an `Error` carrying that epoch's solve-failure message when the
+     * epoch did not converge (check [`SppBatchSolution.isOk`] first).
+     */
+    solution(index: number): SppSolution;
+    /**
+     * Number of epochs in the batch (equals the input epoch count).
+     */
+    readonly count: number;
+}
+
 /**
  * The result of an SPP solve.
  */
@@ -2797,6 +4571,12 @@ export class SppSolution {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Dilution-of-precision scalars (GDOP/PDOP/HDOP/VDOP/TDOP) from the
+     * converged geometry, or `undefined` when the converged geometry is
+     * rank-deficient. The same `Dop` produced by [`gnssDop`](crate::gnss_dop).
+     */
+    readonly dop: Dop | undefined;
     /**
      * `[latRad, lonRad, heightM]` as a `Float64Array` if the solve was asked
      * for geodetic output, otherwise `undefined`.
@@ -2814,6 +4594,13 @@ export class SppSolution {
      * Receiver clock bias, seconds.
      */
     readonly rxClockS: number;
+    /**
+     * Per-constellation time (clock) DOP as a `{ system, tdop }[]`, one entry
+     * per GNSS in the solve in ascending system order (the same order as the
+     * per-system clocks). The first entry's `tdop` equals the reference clock's
+     * `dop.tdop`. Empty when the converged geometry is rank-deficient.
+     */
+    readonly systemTdops: any;
     /**
      * Satellite tokens used in the accepted solution, ascending.
      */
@@ -2893,6 +4680,14 @@ export enum TimeScale {
      * BeiDou Time.
      */
     Bdt = 6,
+    /**
+     * GLONASS system time (UTC(SU)-based, leap-second carrying).
+     */
+    Glonasst = 7,
+    /**
+     * QZSS system time (steered to GPST).
+     */
+    Qzsst = 8,
 }
 
 /**
@@ -2908,6 +4703,14 @@ export class Tle {
      * an end at or before the start.
      */
     findPasses(station: GroundStation, start_unix_us: bigint, end_unix_us: bigint, elevation_mask_deg?: number | null, step_seconds?: number | null, time_tolerance_s?: number | null): SatellitePass[];
+    /**
+     * Sub-satellite (ground-track) WGS84 geodetic points over a `BigInt64Array`
+     * of unix-microsecond epochs. For each epoch the satellite is propagated to
+     * TEME and reduced TEME->GCRS->ECEF->geodetic by the engine's own transforms,
+     * honoring this `Tle`'s opsmode. Throws an `Error` on propagation or frame
+     * failure.
+     */
+    groundTrack(epochs_unix_us: BigInt64Array): GroundTrack;
     /**
      * Topocentric azimuth/elevation/range from `station` over a
      * `BigInt64Array` of unix-microsecond epochs. Throws an `Error` on failure.
@@ -3132,6 +4935,38 @@ export class VisibilitySeries {
     readonly visible: Uint8Array;
 }
 
+/**
+ * One satellite visible above the elevation mask at a single instant, from
+ * [`visibleFromSatellites`].
+ */
+export class VisibleSatellite {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Topocentric azimuth, degrees clockwise from north.
+     */
+    readonly azimuthDeg: number;
+    /**
+     * The caller-supplied identity (the `ids[i]` paired with this satellite):
+     * a NORAD catalog number, a name, or whatever the caller chose.
+     */
+    readonly catalogNumber: string;
+    /**
+     * Topocentric elevation, degrees above the horizon.
+     */
+    readonly elevationDeg: number;
+    /**
+     * TEME position of the satellite at the instant, km, as a length-3
+     * `Float64Array` `[x, y, z]`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Slant range from the ground station, kilometres.
+     */
+    readonly rangeKm: number;
+}
+
 /**
  * WGS84 receiver geodetic coordinates (radians, metres) for DOP.
  */
@@ -3180,6 +5015,40 @@ export class ZenithDelay {
  */
 export function acquire(samples: Float64Array, prn: bigint, options: any): AcquisitionResult;
 
+/**
+ * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
+ *
+ * `latDeg` / `lonDeg` are geodetic degrees, `altKm` geodetic altitude in
+ * kilometres, `year` / `doy` the UT year and day-of-year (1-366), `sec` the
+ * seconds-in-day, and `f107` / `f107a` / `ap` the space-weather indices (daily
+ * F10.7, 81-day centred F10.7 average, and daily magnetic Ap). The local solar
+ * time is derived in the core (`sec/3600 + lonDeg/15`). Delegates to
+ * `sidereon_core::astro::atmosphere::nrlmsise00_with_lst` with `lst = None`, so
+ * the core derives the solar time under its default flags.
+ */
+export function atmosphereDensity(lat_deg: number, lon_deg: number, alt_km: number, year: number, doy: number, sec: number, f107: number, f107a: number, ap: number): AtmosphereDensity;
+
+/**
+ * The canonical quiet-Sun space-weather defaults for NRLMSISE-00. Delegates to
+ * `sidereon_core::astro::atmosphere::{DEFAULT_F107, DEFAULT_F107A, DEFAULT_AP}`.
+ */
+export function atmosphereSpaceWeatherDefaults(): SpaceWeatherDefaults;
+
+/**
+ * Resolve integer ambiguities with a bounded lattice search.
+ *
+ * `floatCycles` and `covariance` match [`lambdaIlsSearch`]. `radius` is the
+ * per-ambiguity integer search half-width (the lattice spans `radius` integers
+ * either side of each rounded float), `candidateLimit` caps the number of
+ * lattice points evaluated before the search aborts, and `ratioThreshold` is the
+ * ratio-test acceptance threshold. Correct in the weakly-correlated regime and a
+ * drop-in match for `lambdaIlsSearch` there; on strongly-correlated geometry
+ * prefer `lambdaIlsSearch`. Returns an `IlsResult`. Throws a `TypeError` on a
+ * malformed shape, a `RangeError` on a non-finite or out-of-domain input, and an
+ * `Error` on a singular covariance or a lattice that exceeds `candidateLimit`.
+ */
+export function boundedIlsSearch(float_cycles: Float64Array, covariance: any, radius: number, candidate_limit: number, ratio_threshold: number): any;
+
 /**
  * One wrapping GPS C/A chip at a zero-based index.
  */
@@ -3205,11 +5074,28 @@ export function carrierFrequencyHz(system: GnssSystem, band: CarrierBand): numbe
  */
 export function changed(diff: any): boolean;
 
+/**
+ * Continuous seconds since J2000 for a civil instant.
+ */
+export function civilToJ2000Seconds(year: number, month: number, day: number, hour: number, minute: number, second: number): number;
+
 /**
  * Carrier-to-noise-density ratio, dB-Hz. `otherLossesDb` defaults to 0.
  */
 export function cn0(eirp_dbw: number, fspl_db: number, receiver_gt_dbk: number, other_losses_db?: number | null): number;
 
+/**
+ * Convert classical orbital elements to an inertial Cartesian state.
+ *
+ * `coe` is a `ClassicalElements` object (see `rv2coe`); only `p`, `ecc`,
+ * `incl`, `raan`, `argp`, and `nu` are required for an ordinary orbit, with
+ * `orbitType` and the auxiliary angles defaulting so the six primary elements
+ * suffice. `mu` is the gravitational parameter (km^3/s^2). Returns
+ * `{ positionKm, velocityKmS }`, each a length-3 `Float64Array`. Delegates to
+ * `sidereon_core::astro::elements::coe2rv`.
+ */
+export function coe2rv(coe: any, mu: number): any;
+
 /**
  * Coherent integration loss from residual frequency error.
  */
@@ -3245,6 +5131,13 @@ export function covarianceIsPositiveSemidefinite(covariance_km2: Float64Array):
  */
 export function covarianceIsSymmetric(covariance_km2: Float64Array): boolean;
 
+/**
+ * Build a look-angle coverage grid for `satellites` and `stations` at the
+ * `epochUnixUs` (Unix microseconds) epoch. Each cell is the per-pair look angle
+ * from `sidereon_core::astro::coverage::look_angles_batch`.
+ */
+export function coverageLookAngles(satellites: Tle[], stations: GroundStation[], epoch_unix_us: bigint): CoverageGrid;
+
 /**
  * Decode Compact RINEX (Hatanaka) bytes into plain RINEX OBS text. Throws a
  * `TypeError` on non-UTF-8 input and an `Error` on a decode failure.
@@ -3258,11 +5151,46 @@ export function decodeCrinex(bytes: Uint8Array): string;
  */
 export function decodeCrinexLines(bytes: Uint8Array): string[];
 
+/**
+ * Decode every CRC-valid RTCM 3 frame in a byte buffer into the message IR.
+ *
+ * Frames whose CRC fails, or whose body cannot be decoded, are skipped and the
+ * scan resynchronizes on the next preamble. Returns an array of message objects,
+ * each tagged with a `type` discriminant (`"msm"`, `"stationCoordinates"`,
+ * `"antennaDescriptor"`, `"gpsEphemeris"`, `"glonassEphemeris"`,
+ * `"unsupported"`). Delegates to `sidereon_core::rtcm::decode_messages`.
+ */
+export function decodeRtcm(bytes: Uint8Array): any;
+
+/**
+ * Decode the single RTCM 3 frame that begins at the start of `bytes`.
+ *
+ * Returns the decoded message object plus the total `frameLen` consumed
+ * (preamble, length word, body, CRC). Throws an `Error` if the preamble is
+ * missing, the buffer is shorter than the declared frame, or the CRC does not
+ * match. Delegates to `sidereon_core::rtcm::decode_frame` +
+ * `sidereon_core::rtcm::Message::decode`.
+ */
+export function decodeRtcmFrame(bytes: Uint8Array): any;
+
+/**
+ * Decode a single RTCM 3 message body without the transport frame.
+ *
+ * `body` is the bytes between the frame length word and CRC. Delegates to
+ * `sidereon_core::rtcm::Message::decode`.
+ */
+export function decodeRtcmMessage(body: Uint8Array): any;
+
 /**
  * Standard dual-frequency ionosphere-free carrier pair for a constellation.
  */
 export function defaultPair(system: GnssSystem): CarrierPair | undefined;
 
+/**
+ * Single-frequency carrier used by the SPP ionosphere-scaling policy.
+ */
+export function defaultSppFrequencyHz(system: GnssSystem): number | undefined;
+
 /**
  * Detect cycle slips on a time-ordered single-satellite carrier-phase arc.
  * `arc` is an array of `{ phi1Cycles?, phi2Cycles?, p1M?, p2M?, lli1?, lli2?,
@@ -3281,59 +5209,211 @@ export function detectCycleSlips(arc: any, options: any): SlipResult[];
 export function dgnssApply(rover_observations: any, corrections: any): AppliedCorrections;
 
 /**
- * Compare two catalog snapshots by `(system, prn)` identity.
+ * Compare two catalog snapshots by `(system, prn)` identity.
+ *
+ * `previous` and `current` are each a `Record[]`. Returns a `Diff` of added,
+ * removed, and per-field changes on held PRNs.
+ */
+export function diff(previous: any, current: any): any;
+
+/**
+ * Parabolic-dish antenna gain, dBi.
+ */
+export function dishGain(diameter_m: number, frequency_hz: number, efficiency: number): number;
+
+/**
+ * Range rate and dimensionless Doppler ratio from a GCRS state.
+ *
+ * `gcrsPositionKm` and `gcrsVelocityKmS` are length-3 `Float64Array`s (km and
+ * km/s). The station is geodetic `stationLatDeg` / `stationLonDeg` (degrees) at
+ * `stationAltKm` (km). The receive epoch is the UTC civil time
+ * `year`/`month`/`day`/`hour`/`minute`/`second`. Returns `[rangeRateKmS,
+ * dopplerRatio]`. Delegates to
+ * `sidereon_core::astro::doppler::range_rate_and_ratio`.
+ */
+export function dopplerRangeRate(gcrs_position_km: Float64Array, gcrs_velocity_km_s: Float64Array, station_lat_deg: number, station_lon_deg: number, station_alt_km: number, year: number, month: number, day: number, hour: number, minute: number, second: number): Float64Array;
+
+/**
+ * Range rate, Doppler ratio, and carrier Doppler shift from a GCRS state.
+ *
+ * Same geometry and epoch inputs as [`dopplerRangeRate`], plus the transmit
+ * `frequencyHz` whose shift is reported. Delegates to
+ * `sidereon_core::astro::doppler::doppler_shift`.
+ */
+export function dopplerShift(gcrs_position_km: Float64Array, gcrs_velocity_km_s: Float64Array, station_lat_deg: number, station_lon_deg: number, station_alt_km: number, year: number, month: number, day: number, hour: number, minute: number, second: number, frequency_hz: number): DopplerShift;
+
+/**
+ * Convert a Doppler shift in hertz to pseudorange rate in metres per second.
+ */
+export function dopplerToRangeRate(doppler_hz: number, carrier_hz: number): number;
+
+/**
+ * Angular radius in degrees of Earth as seen from each satellite position.
+ */
+export function earthAngularRadius(satellite_position_km: Float64Array): Float64Array;
+
+/**
+ * Convert a batch of ITRS (ECEF) positions to geodetic coordinates.
+ *
+ * `positionKm` is a flat row-major `(n, 3)` `Float64Array` in kilometres.
+ * Returns a flat `(n, 3)` `Float64Array` whose columns are
+ * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Time-independent.
+ */
+export function ecefToGeodetic(position_km: Float64Array): Float64Array;
+
+/**
+ * Eclipse status for satellite and Sun position batches, km. Returns a
+ * `string[]` of `"sunlit"` / `"penumbra"` / `"umbra"`.
+ */
+export function eclipseStatus(satellite_position_km: Float64Array, sun_position_km: Float64Array): string[];
+
+/**
+ * Effective isotropic radiated power, dBW.
+ */
+export function eirp(tx_power_dbm: number, tx_antenna_gain_dbi: number): number;
+
+/**
+ * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
+ * orthometric height and a geodetic position in radians, using the built-in
+ * grid's undulation. Delegates to
+ * `sidereon_core::geoid::ellipsoidal_height_m`.
+ */
+export function ellipsoidalHeightM(orthometric_height_m: number, lat_rad: number, lon_rad: number): number;
+
+/**
+ * Encode plain RINEX observation text into a Compact RINEX (Hatanaka) stream,
+ * the inverse of [`decodeCrinex`]. RINEX 2 is emitted as CRINEX 1.0 and RINEX 3
+ * as CRINEX 3.0, selected from the embedded `RINEX VERSION / TYPE` header. The
+ * output is the canonical all-reset compression form, so it round-trips
+ * (`decodeCrinex(encodeCrinex(rinex)) == rinex`) but is not byte-identical to an
+ * arbitrary `RNX2CRX` stream. Throws an `Error` on malformed input. Delegates to
+ * `sidereon_core::rinex::crinex::encode_crinex`.
+ */
+export function encodeCrinex(rinex_text: string): string;
+
+/**
+ * Encode a constructed RTCM message into a message body (without the transport
+ * frame).
+ *
+ * `message` is a `type`-tagged plain object of the same shape [`decodeRtcm`]
+ * returns (`"stationCoordinates"`, `"antennaDescriptor"`, `"gpsEphemeris"`,
+ * `"glonassEphemeris"`, `"msm"`, `"unsupported"`), carrying the raw transmitted
+ * field integers (large fields as `bigint`). Returns the encoded body as a
+ * `Uint8Array`. Delegates to `sidereon_core::rtcm::Message::encode`. Throws a
+ * `TypeError` for a malformed object or unknown type.
+ */
+export function encodeRtcm(message: any): Uint8Array;
+
+/**
+ * Encode a constructed RTCM message and wrap it in a fresh RTCM transport frame
+ * (preamble, length word, body, CRC).
+ *
+ * `message` has the same shape [`encodeRtcm`] takes. Returns the framed bytes as
+ * a `Uint8Array`, ready to feed back to [`decodeRtcmFrame`] / [`decodeRtcm`].
+ * Delegates to `sidereon_core::rtcm::Message::to_frame`. Throws a `TypeError`
+ * for a malformed object and an `Error` if the encoded body exceeds the frame
+ * length limit.
+ */
+export function encodeRtcmFrame(message: any): Uint8Array;
+
+/**
+ * Build the encounter frame from two position/velocity states (each a length-3
+ * `Float64Array`).
+ */
+export function encounterFrame(position1_km: Float64Array, velocity1_km_s: Float64Array, position2_km: Float64Array, velocity2_km_s: Float64Array): EncounterFrame;
+
+/**
+ * Project a 3x3 ECI covariance into the encounter B-plane `(x, z)`. Returns a
+ * flat row-major length-4 (2-by-2) `Float64Array`.
+ */
+export function encounterPlaneCovariance(frame: EncounterFrame, covariance_km2: Float64Array): Float64Array;
+
+/**
+ * Find local TCA candidates between two satellites over a UTC window.
  *
- * `previous` and `current` are each a `Record[]`. Returns a `Diff` of added,
- * removed, and per-field changes on held PRNs.
+ * `primaryLine1` / `primaryLine2` and `secondaryLine1` / `secondaryLine2` are
+ * the TLE line pairs; `windowStartUnixMicros` / `windowEndUnixMicros` are the
+ * window bounds as unix-microsecond UTC stamps (`bigint`); `options` is an
+ * optional `TcaFinderOptions` object. Returns an array of `TcaCandidate`
+ * objects. Delegates to
+ * `sidereon_core::astro::tca::find_tca_candidates_from_tles`.
  */
-export function diff(previous: any, current: any): any;
+export function findTcaCandidates(primary_line1: string, primary_line2: string, secondary_line1: string, secondary_line2: string, window_start_unix_micros: bigint, window_end_unix_micros: bigint, options: any): any;
 
 /**
- * Parabolic-dish antenna gain, dBi.
+ * Find local TCA candidates between two satellites and evaluate collision
+ * probability at each.
+ *
+ * Like `findTcaCandidates`, plus `pcOptions` (a `TcaPcOptions` object with the
+ * hard-body radius, Pc method, and optional per-object covariances). Returns an
+ * array of `TcaConjunction` objects. Delegates to
+ * `sidereon_core::astro::tca::find_tca_conjunctions_from_tles`.
  */
-export function dishGain(diameter_m: number, frequency_hz: number, efficiency: number): number;
+export function findTcaConjunctions(primary_line1: string, primary_line2: string, secondary_line1: string, secondary_line2: string, window_start_unix_micros: bigint, window_end_unix_micros: bigint, pc_options: any, options: any): any;
 
 /**
- * Convert a Doppler shift in hertz to pseudorange rate in metres per second.
+ * Fit a piecewise reduced-orbit model: tile `[t0, t1]` into segments of
+ * `segmentSeconds` and fit each independently.
+ *
+ * `samples` is an array of `{ epoch, xM, yM, zM }` (ECEF metres), `scale` the
+ * time scale the epochs are expressed in, and `model` is `"circular_secular"`
+ * or `"eccentric_secular"`. `t0` / `t1` are `{ year, month, day, hour, minute,
+ * second }` calendar epochs in that scale. Delegates to
+ * `sidereon_core::orbit::fit_piecewise`.
  */
-export function dopplerToRangeRate(doppler_hz: number, carrier_hz: number): number;
+export function fitPiecewiseReducedOrbit(samples: any, scale: TimeScale, model: string, t0: any, t1: any, segment_seconds: number): PiecewiseOrbit;
 
 /**
- * Angular radius in degrees of Earth as seen from each satellite position.
+ * Sample an SP3 product and fit a piecewise reduced orbit.
+ *
+ * `options` is `{ t0, t1, cadenceS, model, segmentSeconds }`. Epochs are
+ * interpreted in the SP3 product time scale. Delegates to
+ * `sidereon_core::orbit::fit_piecewise_reduced_orbit_source`.
  */
-export function earthAngularRadius(satellite_position_km: Float64Array): Float64Array;
+export function fitPiecewiseReducedOrbitSp3(sp3: Sp3, satellite: string, options: any): PiecewiseOrbitSourceFit;
 
 /**
- * Convert a batch of ITRS (ECEF) positions to geodetic coordinates.
+ * Sample a TLE/SGP4 source in UTC and fit a piecewise reduced orbit.
  *
- * `positionKm` is a flat row-major `(n, 3)` `Float64Array` in kilometres.
- * Returns a flat `(n, 3)` `Float64Array` whose columns are
- * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Time-independent.
+ * `options` is `{ t0, t1, cadenceS, model, segmentSeconds }`. Delegates to
+ * `sidereon_core::orbit::fit_piecewise_reduced_orbit_source`.
  */
-export function ecefToGeodetic(position_km: Float64Array): Float64Array;
+export function fitPiecewiseReducedOrbitTle(tle: Tle, options: any): PiecewiseOrbitSourceFit;
 
 /**
- * Eclipse status for satellite and Sun position batches, km. Returns a
- * `string[]` of `"sunlit"` / `"penumbra"` / `"umbra"`.
+ * Fit a reduced-orbit model to ECEF position samples.
+ *
+ * `samples` is an array of `{ epoch, xM, yM, zM }` (ECEF metres), `scale` the
+ * time scale the epochs are expressed in, and `model` is `"circular_secular"`
+ * or `"eccentric_secular"`. Delegates to `sidereon_core::orbit::fit_with_model`.
  */
-export function eclipseStatus(satellite_position_km: Float64Array, sun_position_km: Float64Array): string[];
+export function fitReducedOrbit(samples: any, scale: TimeScale, model: string): ReducedOrbit;
 
 /**
- * Effective isotropic radiated power, dBW.
+ * Sample an SP3 product and fit a reduced orbit.
+ *
+ * `options` is `{ t0, t1, cadenceS, model }`. Epochs are interpreted in the
+ * SP3 product time scale. Delegates to
+ * `sidereon_core::orbit::fit_reduced_orbit_source`.
  */
-export function eirp(tx_power_dbm: number, tx_antenna_gain_dbi: number): number;
+export function fitReducedOrbitSp3(sp3: Sp3, satellite: string, options: any): ReducedOrbitSourceFit;
 
 /**
- * Build the encounter frame from two position/velocity states (each a length-3
- * `Float64Array`).
+ * Sample a TLE/SGP4 source in UTC and fit a reduced orbit.
+ *
+ * `options` is `{ t0, t1, cadenceS, model }`. Delegates to
+ * `sidereon_core::orbit::fit_reduced_orbit_source`.
  */
-export function encounterFrame(position1_km: Float64Array, velocity1_km_s: Float64Array, position2_km: Float64Array, velocity2_km_s: Float64Array): EncounterFrame;
+export function fitReducedOrbitTle(tle: Tle, options: any): ReducedOrbitSourceFit;
 
 /**
- * Project a 3x3 ECI covariance into the encounter B-plane `(x, z)`. Returns a
- * flat row-major length-4 (2-by-2) `Float64Array`.
+ * Fix Melbourne-Wubbena wide-lane ambiguities over a dual-frequency RTK arc.
+ *
+ * `epochs` is an array of `RtkDualFrequencyArcEpoch` objects and `config` a
+ * `RtkWideLaneArcConfig` object. Delegates to
+ * `sidereon_core::rtk_filter::arc::fix_wide_lane_rtk_arc`.
  */
-export function encounterPlaneCovariance(frame: EncounterFrame, covariance_km2: Float64Array): Float64Array;
+export function fixWideLaneRtkArc(epochs: any, config: any): any;
 
 /**
  * J2 oblateness gravitational acceleration in km/s^2.
@@ -3357,19 +5437,53 @@ export function forceJ2Acceleration(position_km: Float64Array, velocity_km_s: Fl
 export function forceTwoBodyAcceleration(position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
 
 /**
- * Build GPS identity records from CelesTrak `gps-ops` OMM JSON-array text.
+ * Build constellation identity records from a CelesTrak OMM JSON-array text.
+ *
+ * `system` is the constellation label (`"gps"`, `"glonass"`, `"galileo"`,
+ * `"beidou"`, `"qzss"`); it dispatches the per-system `OBJECT_NAME` identity
+ * adapter and defaults to `"gps"`. Parses the CelesTrak JSON array into OMM
+ * records (skipping array elements that are not parseable OMM objects), then
+ * derives normalized `Record` rows sorted by `(system, prn)`. Returns a
+ * `Record[]`. Throws an `Error` on a JSON parse failure or a CelesTrak object
+ * name with no PRN resolvable for `system`.
+ */
+export function fromCelestrakJson(json: string, system?: string | null): any;
+
+/**
+ * Build constellation identity records from a CelesTrak OMM JSON-array text,
+ * skipping (rather than throwing on) entries that do not resolve.
  *
- * Parses the CelesTrak JSON array into OMM records, then derives normalized
- * `Record` rows (sorted by PRN). Returns a `Record[]`. Throws an `Error` on a
- * JSON parse failure or a CelesTrak object name with no parseable PRN.
+ * The lenient sibling of [`fromCelestrakJson`]: feed it a raw combined CelesTrak
+ * `gnss` feed and it returns `{ records, skipped }` — `records` is the `Record[]`
+ * for `system` (the same shape `fromCelestrakJson` returns, sorted by
+ * `(system, prn)`), and `skipped` is a `SkippedOmm[]` of the entries whose
+ * `OBJECT_NAME` did not resolve to a PRN for `system` (another constellation's
+ * satellite in the combined feed, or a freshly launched satellite not yet in the
+ * published slot/SVID table), each carrying its `{ objectName?, noradId }` so the
+ * caller can triage. `system` defaults to `"gps"`. Throws an `Error` only on a
+ * JSON parse failure.
  */
-export function fromCelestrakJson(json: string): any;
+export function fromCelestrakJsonLenient(json: string, system?: string | null): any;
 
 /**
  * Free-space path loss, dB, for range in km and frequency in MHz.
  */
 export function fspl(distance_km: number, frequency_mhz: number): number;
 
+/**
+ * Galileo NeQuick-G single-frequency ionospheric group delay (positive metres).
+ *
+ * `ai0`/`ai1`/`ai2` are the three Galileo broadcast NeQuick-G coefficients.
+ * `latDeg`/`lonDeg` are the receiver geodetic coordinates, `azimuthDeg` /
+ * `elevationDeg` the satellite topocentric angles (degrees). The receive epoch
+ * is the UTC civil time `year`/`month`/`day`/`hour`/`minute`/`second`, taken in
+ * Galileo System Time. `frequencyHz` is the reporting carrier. Delegates to
+ * `sidereon_core::atmosphere::ionosphere::ionosphere_delay` with
+ * `IonoModel::GalileoNequickG`, which dispatches to the Galileo arm. Throws an
+ * `Error` on an out-of-domain input.
+ */
+export function galileoNequickDelay(ai0: number, ai1: number, ai2: number, lat_deg: number, lon_deg: number, azimuth_deg: number, elevation_deg: number, year: number, month: number, day: number, hour: number, minute: number, second: number, frequency_hz: number): number;
+
 /**
  * Ionosphere-free coefficient `gamma = f1^2 / (f1^2 - f2^2)`.
  */
@@ -3390,11 +5504,31 @@ export function gcrsToItrs(position_km: Float64Array, epochs_unix_us: BigInt64Ar
  */
 export function geodeticToEcef(geodetic: Float64Array): Float64Array;
 
+/**
+ * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
+ * position in radians, from the COARSE built-in global grid. Latitude is
+ * positive north, longitude positive east. Delegates to
+ * `sidereon_core::geoid::geoid_undulation`.
+ */
+export function geoidUndulation(lat_rad: number, lon_rad: number): number;
+
 /**
  * Geometry-free phase combination `L_GF = L1 - L2`, metres.
  */
 export function geometryFree(l1_m: number, l2_m: number): number;
 
+/**
+ * GLONASS FDMA L1/L2 frequency-channel number (`k`, in `-7..=6`) for an
+ * orbital slot, from the published IGS/MCC slot-channel table. Returns `null`
+ * for a slot with no tabulated channel.
+ */
+export function glonassFdmaChannel(slot: number): number | undefined;
+
+/**
+ * GLONASS G1 FDMA carrier frequency in hertz for channel `k`.
+ */
+export function glonassG1FrequencyHz(channel: number): number;
+
 /**
  * GNSS dilution of precision from ECEF line-of-sight unit rows and weights.
  *
@@ -3403,6 +5537,16 @@ export function geometryFree(l1_m: number, l2_m: number): number;
  */
 export function gnssDop(line_of_sight: Float64Array, weights: Float64Array, receiver: Wgs84Geodetic): Dop;
 
+/**
+ * Compute exact GNSS DOP at a single epoch from an SP3 precise product.
+ *
+ * `stationEcefM` is an ECEF metre vector (length 3); `j2000Seconds` the receive
+ * time as continuous seconds since J2000 in the SP3 product time scale.
+ * `options` is `{ satellites?, elevationMaskDeg?=5, systems?, weighting?="unit",
+ * lightTime?=false }`. Delegates to `sidereon_core::geometry::dop_at_epoch`.
+ */
+export function gnssDopAtEpoch(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: number, options: any): DopGeometry;
+
 /**
  * Sample SP3-derived GNSS DOP over a J2000 epoch grid.
  *
@@ -3413,6 +5557,26 @@ export function gnssDop(line_of_sight: Float64Array, weights: Float64Array, rece
  */
 export function gnssDopSeries(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: Float64Array, options: any): DopSeries;
 
+/**
+ * Sample exact GNSS DOP over an inclusive uniform window `[startJ2000S,
+ * endJ2000S]` at `stepSeconds` spacing, skipping singular or underdetermined
+ * samples. `options` is the same shape as [`gnssDopAtEpoch`]. Delegates to
+ * `sidereon_core::geometry::dop_series`.
+ */
+export function gnssDopSeriesWindow(sp3: Sp3, station_ecef_m: Float64Array, start_j2000_s: number, end_j2000_s: number, step_seconds: number, options: any): DopSeriesSample[];
+
+/**
+ * Sampled visibility passes over `[startJ2000S, endJ2000S]` at `stepSeconds`
+ * spacing. Delegates to `sidereon_core::geometry::passes`.
+ */
+export function gnssPasses(sp3: Sp3, station_ecef_m: Float64Array, start_j2000_s: number, end_j2000_s: number, step_seconds: number, options: any): GnssPass[];
+
+/**
+ * Render the canonical SP3/RINEX satellite token for a constellation + PRN
+ * (`("gps", 7)` -> `"G07"`, `("glonass", 13)` -> `"R13"`).
+ */
+export function gnssSp3Id(system: string, prn: number): string;
+
 /**
  * Stable lower-case display label for a constellation, e.g. `"gps"`.
  */
@@ -3423,6 +5587,51 @@ export function gnssSystemLabel(system: GnssSystem): string;
  */
 export function gnssSystemLetter(system: GnssSystem): string;
 
+/**
+ * Visible-satellite counts over `[startJ2000S, endJ2000S]` sampled every
+ * `stepSeconds`. Delegates to `sidereon_core::geometry::visibility_series`.
+ */
+export function gnssVisibilitySeries(sp3: Sp3, station_ecef_m: Float64Array, start_j2000_s: number, end_j2000_s: number, step_seconds: number, options: any): GnssVisibilityCount[];
+
+/**
+ * Satellites visible above the elevation mask from an SP3 product at one
+ * receive epoch. `stationEcefM` is a length-3 `Float64Array` (ECEF metres),
+ * `j2000Seconds` the receive time as continuous seconds since J2000.
+ * Delegates to `sidereon_core::geometry::visible`.
+ */
+export function gnssVisible(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: number, options: any): GnssVisibleSatellite[];
+
+/**
+ * Gauss angles-only orbit determination.
+ *
+ * `decl` and `rtasc` are length-3 declination / right-ascension
+ * `Float64Array`s (radians), `jd` and `jdf` length-3 split Julian dates (whole
+ * part and fraction, days), and `rseci` a flat row-major `(3, 3)`
+ * `Float64Array` of observer-site ECI positions (km), one row per epoch.
+ * Returns the orbit state at the middle observation. Delegates to
+ * `sidereon_core::astro::iod::gauss_angles`.
+ */
+export function iodGaussAngles(decl: Float64Array, rtasc: Float64Array, jd: Float64Array, jdf: Float64Array, rseci: Float64Array): IodState;
+
+/**
+ * Gibbs three-position velocity solve.
+ *
+ * `r1`, `r2`, `r3` are length-3 coplanar geocentric position `Float64Array`s
+ * (km). Returns the velocity at `r2` plus the inter-vector and coplanarity
+ * angles. Delegates to `sidereon_core::astro::iod::gibbs`.
+ */
+export function iodGibbs(r1: Float64Array, r2: Float64Array, r3: Float64Array): IodVelocity;
+
+/**
+ * Herrick-Gibbs three-position velocity solve.
+ *
+ * `r1`, `r2`, `r3` are length-3 closely-spaced geocentric position
+ * `Float64Array`s (km) and `jd1`/`jd2`/`jd3` their Julian-date epochs (days).
+ * Returns the velocity at `r2` plus the inter-vector and coplanarity angles.
+ * Delegates to `sidereon_core::astro::iod::hgibbs`.
+ */
+export function iodHerrickGibbs(r1: Float64Array, r2: Float64Array, r3: Float64Array, jd1: number, jd2: number, jd3: number): IodVelocity;
+
 /**
  * Ionosphere-free code or meter-valued phase combination, metres.
  */
@@ -3456,6 +5665,54 @@ export function isValid(validation: any): boolean;
  */
 export function itrsToGcrs(position_km: Float64Array, epochs_unix_us: BigInt64Array): Float64Array;
 
+/**
+ * Civil calendar fields from whole seconds since J2000.
+ */
+export function j2000SecondsToCivil(seconds: bigint): CivilDateTime;
+
+/**
+ * GPS broadcast Klobuchar ionospheric group delay in the model's native units
+ * (positive metres).
+ *
+ * `alpha` and `beta` are the eight transmitted GPS Klobuchar coefficients, each
+ * a length-4 `Float64Array` (`a0..a3`, `b0..b3`). Receiver latitude/longitude
+ * and satellite azimuth/elevation are degrees (latitude positive north,
+ * longitude positive east, azimuth clockwise from north). `tGpsS` is the GPS
+ * second-of-day in `[0, 86400)`. `frequencyHz` is the carrier the dispersive
+ * delay is reported on; the model evaluates the L1 delay and scales it by the
+ * dispersive `(f_l1 / f)^2` factor. Delegates to
+ * `sidereon_core::atmosphere::ionosphere::klobuchar_native`. Throws an `Error`
+ * on an out-of-domain coefficient, angle, time, or frequency.
+ */
+export function klobucharDelay(alpha: Float64Array, beta: Float64Array, lat_deg: number, lon_deg: number, azimuth_deg: number, elevation_deg: number, t_gps_s: number, frequency_hz: number): number;
+
+/**
+ * Resolve integer ambiguities with the LAMBDA method (RTKLIB `lambda()` port).
+ *
+ * `floatCycles` is the real-valued ambiguity vector (`Float64Array`),
+ * `covariance` is its `n x n` covariance as a row-major `number[][]`, and
+ * `ratioThreshold` is the ratio-test acceptance threshold (RTKLIB's default is
+ * `3.0`). Finds the true integer-least-squares optimum and runner-up for any
+ * positive-definite covariance — no search box, no combinatorial blow-up.
+ * Returns an `IlsResult`. Throws a `TypeError` on a malformed shape, a
+ * `RangeError` on a non-finite or out-of-domain input, and an `Error` on a
+ * singular covariance or a non-converging search.
+ */
+export function lambdaIlsSearch(float_cycles: Float64Array, covariance: any, ratio_threshold: number): any;
+
+/**
+ * Solve Lambert's problem with Battin's method.
+ *
+ * `r1`, `r2` are length-3 position `Float64Array`s (km) and `dtsec` the time of
+ * flight (seconds). `v1` (length-3, km/s) is only consulted for the degenerate
+ * 180-degree transfer where the transfer-plane normal is otherwise undefined.
+ * `directionOfMotion` is `"short"` or `"long"`, `directionOfEnergy` is `"low"`
+ * or `"high"`, and `nrev` is the number of complete revolutions. Returns the
+ * departure and arrival transfer velocities. Delegates to
+ * `sidereon_core::astro::lambert::battin`.
+ */
+export function lambertBattin(r1: Float64Array, r2: Float64Array, v1: Float64Array, dtsec: number, direction_of_motion_label: string, direction_of_energy_label: string, nrev: number): LambertTransfer;
+
 /**
  * Provenance and coverage of the embedded leap-second (TAI-UTC) table.
  */
@@ -3472,6 +5729,62 @@ export function leapSeconds(year: number, month: number, day: number): number;
  */
 export function leapSecondsBatch(dates: Int32Array): Float64Array;
 
+/**
+ * Decode LNAV subframes 1-3 back into engineering-unit parameters.
+ *
+ * Each subframe is a 300-bit `Uint8Array` of `0`/`1`. Parity is verified on all
+ * 30 words first; a failure throws an `Error`. Delegates to
+ * `sidereon_core::navigation::lnav::decode`.
+ */
+export function lnavDecode(sf1: Uint8Array, sf2: Uint8Array, sf3: Uint8Array): LnavDecoded;
+
+/**
+ * Encode clock and ephemeris parameters into LNAV subframes 1-3.
+ *
+ * `params` is the engineering-unit parameter object and `options` the optional
+ * TLM/HOW object (omitted fields default to `0`). Returns the three 300-bit
+ * subframes. Throws an `Error` on an out-of-range field. Delegates to
+ * `sidereon_core::navigation::lnav::encode`.
+ */
+export function lnavEncode(params: any, options: any): LnavSubframes;
+
+/**
+ * The six parity bits `[D25..D30]` of a word from its 24 source data bits.
+ *
+ * `data24` is the 24 source data bits (most significant first, before the
+ * `D30*` complementation). `d29Prev` / `d30Prev` are the previous word's two
+ * trailing parity bits. Delegates to `sidereon_core::navigation::lnav::parity`.
+ */
+export function lnavParity(data24: Uint8Array, d29_prev: number, d30_prev: number): Uint8Array;
+
+/**
+ * Verify the parity of a single 30-bit word.
+ *
+ * `word30` is the 30-bit word as transmitted (data bits possibly complemented
+ * by `D30*`, then 6 received parity bits). `d29Prev` / `d30Prev` are the
+ * previous word's trailing parity bits. Delegates to
+ * `sidereon_core::navigation::lnav::parity_valid`.
+ */
+export function lnavParityValid(word30: Uint8Array, d29_prev: number, d30_prev: number): boolean;
+
+/**
+ * Subframe ID from a hand-over word or a full subframe.
+ *
+ * `bits` is a 30-bit HOW word or a 300-bit subframe. Returns the 3-bit subframe
+ * ID, or `undefined` for any other length. Delegates to
+ * `sidereon_core::navigation::lnav::subframe_id`.
+ */
+export function lnavSubframeId(bits: Uint8Array): bigint | undefined;
+
+/**
+ * Time-of-week count from a hand-over word or a full subframe.
+ *
+ * `bits` is a 30-bit HOW word or a 300-bit subframe (whose word 2 is the HOW),
+ * as a `Uint8Array` of `0`/`1`. Returns the 17-bit TOW count, or `undefined`
+ * for any other length. Delegates to `sidereon_core::navigation::lnav::tow`.
+ */
+export function lnavTow(bits: Uint8Array): bigint | undefined;
+
 /**
  * Parse an ANTEX 1.4 antenna product from in-memory bytes (a `Uint8Array`).
  * Throws an `Error` on a parse failure or non-UTF-8 input.
@@ -3556,16 +5869,86 @@ export function narrowLaneCode(p1_m: number, p2_m: number, f1_hz: number, f2_hz:
  */
 export function navMessageLabel(message: NavMessage): string;
 
+/**
+ * Full NeQuick-G slant ionospheric group delay (positive metres) on
+ * `frequencyHz`.
+ *
+ * The slant TEC from [`nequick_g_stec_tecu_js`] mapped to a group delay with the
+ * dispersive `40.3e16 / f^2` relation. `eval` is a plain object; see the
+ * `NequickGEval` TypeScript type. Delegates to
+ * `sidereon_core::atmosphere::ionosphere::nequick_g_delay_m`. Throws a
+ * `TypeError` for a malformed object and an `Error` for an out-of-domain input
+ * or non-positive frequency.
+ */
+export function nequickGDelayM(_eval: any, frequency_hz: number): number;
+
+/**
+ * Full NeQuick-G slant total electron content along the ray, in TECU.
+ *
+ * Unlike the compact broadcast-driven [`galileo_nequick_delay`], this evaluates
+ * the complete three-dimensional NeQuick 2 electron-density profiler integrated
+ * along the receiver-to-satellite ray with the reference adaptive
+ * Gauss-Kronrod quadrature. `eval` is a plain object; see the `NequickGEval`
+ * TypeScript type. Delegates to
+ * `sidereon_core::atmosphere::ionosphere::nequick_g_stec_tecu`. Throws a
+ * `TypeError` for a malformed object and an `Error` for an out-of-domain month,
+ * UTC, latitude, or a geometrically invalid ray.
+ */
+export function nequickGStecTecu(_eval: any): number;
+
 /**
  * Equal-variance noise amplification of the ionosphere-free combination.
  */
 export function noiseAmplification(f1_hz: number, f2_hz: number): number;
 
+/**
+ * Predict observables for one satellite from a broadcast ephemeris store.
+ * Delegates to `sidereon_core::observables::predict`.
+ */
+export function observablesBroadcast(broadcast: BroadcastEphemeris, satellite: string, receiver_ecef_m: Float64Array, t_rx_j2000_s: number, options: any): PredictedObservables;
+
+/**
+ * Predict observables for one satellite from an SP3 precise product. See
+ * [`observablesBroadcast`] for the broadcast-ephemeris counterpart. Delegates
+ * to `sidereon_core::observables::predict`.
+ */
+export function observablesSp3(sp3: Sp3, satellite: string, receiver_ecef_m: Float64Array, t_rx_j2000_s: number, options: any): PredictedObservables;
+
 /**
  * Stable lower-case label for an observation kind.
  */
 export function observationKindLabel(kind: ObservationKind): string;
 
+/**
+ * Ocean tide loading displacement of an ITRF station, metres (ECEF).
+ *
+ * `stationEcefM` is a length-3 geocentric ECEF metre vector and the epoch is
+ * the UTC `year`/`month`/`day` plus `fractionalHour`. `amplitudeM` and
+ * `phaseDeg` are the station's BLQ coefficients as flat row-major
+ * `(3, 11)` `Float64Array`s: component order radial / EW-west / NS-south, and
+ * constituent order M2 S2 N2 K2 K1 O1 P1 Q1 Mf Mm Ssa. Returns the displacement
+ * `[dx, dy, dz]`. Delegates to `sidereon_core::tides::ocean_tide_loading`.
+ */
+export function oceanTideLoading(station_ecef_m: Float64Array, year: number, month: number, day: number, fractional_hour: number, amplitude_m: Float64Array, phase_deg: Float64Array): Float64Array;
+
+/**
+ * Orthometric height `H = h - N` (metres above mean sea level) from an
+ * ellipsoidal height and a geodetic position in radians, using the built-in
+ * grid's undulation. Delegates to
+ * `sidereon_core::geoid::orthometric_height_m`.
+ */
+export function orthometricHeightM(ellipsoidal_height_m: number, lat_rad: number, lon_rad: number): number;
+
+/**
+ * Parallactic angle (degrees) of a target at a station.
+ *
+ * `observerLatitudeDeg` is the observer geodetic latitude, `hourAngleDeg` the
+ * local hour angle (positive west of the meridian), and `declinationDeg` the
+ * target declination. The result is on `(-180, 180]`. Delegates to
+ * `sidereon_core::astro::observation::parallactic_angle_deg`.
+ */
+export function parallacticAngleDeg(observer_latitude_deg: number, hour_angle_deg: number, declination_deg: number): number;
+
 /**
  * Parse CCSDS CDM KVN text. Throws an `Error` on a parse failure.
  */
@@ -3584,6 +5967,18 @@ export function parseCdmXml(text: string): Cdm;
  */
 export function parseNavcen(html: string): any;
 
+/**
+ * Parse CCSDS OEM KVN text. The KVN reader is forgiving: malformed ephemeris
+ * lines are skipped and counted in `skippedStates`. Throws an `Error` on a
+ * structural failure.
+ */
+export function parseOemKvn(text: string): Oem;
+
+/**
+ * Parse CCSDS OEM XML text. Throws an `Error` on a parse failure.
+ */
+export function parseOemXml(text: string): Oem;
+
 /**
  * Parse CCSDS/CelesTrak OMM JSON text. Throws an `Error` on a parse failure.
  */
@@ -3599,6 +5994,16 @@ export function parseOmmKvn(text: string): Omm;
  */
 export function parseOmmXml(text: string): Omm;
 
+/**
+ * Parse CCSDS OPM KVN text. Throws an `Error` on a parse failure.
+ */
+export function parseOpmKvn(text: string): Opm;
+
+/**
+ * Parse CCSDS OPM XML text. Throws an `Error` on a parse failure.
+ */
+export function parseOpmXml(text: string): Opm;
+
 /**
  * Strictly parse RINEX clock bytes into satellite clock-bias series. Throws a
  * `TypeError` on non-UTF-8 input and an `Error` on a malformed record.
@@ -3644,6 +6049,16 @@ export function parseRinexNavRecords(bytes: Uint8Array): BroadcastRecordJs[];
  */
 export function parseRinexObs(bytes: Uint8Array): RinexObs;
 
+/**
+ * Parse a multi-record TLE file (CelesTrak / Space-Track style) into named,
+ * initialized [`Tle`] instances. Handles bare 2-line sets, 3-line name+line1+line2
+ * sets, and CelesTrak `0 NAME` markers; CRLF endings, blank lines, and
+ * surrounding whitespace are tolerated. A record whose element set fails SGP4
+ * initialization is skipped and counted in `skipped` rather than aborting the
+ * whole file. `opsMode` is `"improved"` (default) or `"afspc"`.
+ */
+export function parseTleFile(text: string, ops_mode_label?: string | null): ParsedTleFile;
+
 /**
  * Sun-satellite-observer phase angle in degrees.
  */
@@ -3654,6 +6069,52 @@ export function phaseAngle(satellite_position_km: Float64Array, sun_position_km:
  */
 export function phaseMeters(phi_cycles: number, f_hz: number): number;
 
+/**
+ * Precompute static PPP correction tables for a precise-orbit arc.
+ *
+ * `epochs` is an array of `PppCorrectionEpoch` objects, `receiverEcefM` is the
+ * fixed receiver position (`Float64Array` of length 3, metres), and `options`
+ * selects which corrections to compute: `solidEarthTide` / `phaseWindup`
+ * booleans, plus optional `satelliteAntenna` (a `PppSatelliteAntennaOptions`),
+ * `poleTide` (a `PoleTideOptions`, the IERS polar motion of the date), and
+ * `oceanLoading` (an `OceanLoadingBlq`, the station's BLQ block). Returns a
+ * `PppCorrections` whose fields are each keyed by the input epoch index. Throws a
+ * `TypeError` on a malformed shape or an invalid satellite token, and an `Error`
+ * on an invalid epoch or a tide/coverage failure.
+ */
+export function pppCorrections(sp3: Sp3, epochs: any, receiver_ecef_m: Float64Array, options: any): any;
+
+/**
+ * Prepare ionosphere-free single-frequency RTK arc inputs from a
+ * dual-frequency arc and fixed wide-lane ambiguities.
+ *
+ * `epochs` is an array of `RtkDualFrequencyArcEpoch` objects, `wideLaneCycles`
+ * is an id-keyed integer object, and `config` is an
+ * `RtkIonosphereFreeArcConfig` object. Delegates to
+ * `sidereon_core::rtk_filter::arc::prepare_ionosphere_free_rtk_arc`.
+ */
+export function prepareIonosphereFreeRtkArc(epochs: any, wide_lane_cycles: any, config: any): any;
+
+/**
+ * Propagate a fleet of already-initialized [`Tle`]s over a shared epoch grid in
+ * a single call: the batched form of [`Tle.propagate`].
+ *
+ * Element `(i, j)` of the result is `satellites[i]` propagated to
+ * `epochsUnixUs[j]`, bit-for-bit identical to `satellites[i].propagate([
+ * epochsUnixUs[j] ])` on its own; this is a thin wrapper over the engine's
+ * serial batch kernel (the binding never spawns the rayon thread pool, since
+ * wasm is single-threaded). Each `Tle` carries the opsmode it was constructed
+ * with, so a deep-space / opsmode-sensitive object is propagated in its own
+ * mode. The `Tle` instances are consumed by this call.
+ *
+ * `epochsUnixUs` is a `BigInt64Array` of unix-microsecond UTC epochs shared by
+ * every satellite. The hot case for a constellation animation is a single epoch
+ * (`epochCount == 1`), giving one TEME state per satellite, but any epoch count
+ * is supported. An empty fleet or empty epoch grid yields empty arrays. Throws
+ * an `Error` (naming the satellite index) if a satellite fails to propagate.
+ */
+export function propagateBatch(satellites: Tle[], epochs_unix_us: BigInt64Array): FleetPropagation;
+
 /**
  * Numerically propagate an ECI Cartesian state and sample it at a grid of
  * epochs.
@@ -3675,6 +6136,20 @@ export function pseudorangeDropReasonLabel(reason: PseudorangeDropReason): strin
  */
 export function pseudorangeVariance(elevation_deg: number, options: any): number;
 
+/**
+ * Run standalone range RAIM/FDE over a linearized measurement set.
+ *
+ * `rows` is an array of `{ id, residualM, designRow, weight }` objects (each
+ * `designRow` the measurement's design-matrix row, of length equal to the
+ * estimated state dimension). `options` is an optional `{ pFa?, maxExclusions?,
+ * minRedundancy? }` object (pass `undefined` for the core defaults). Returns the
+ * protected state correction, covariance, global chi-square test, the excluded
+ * ids, the per-measurement diagnostics, and the exclusion count. Delegates to
+ * `sidereon_core::quality::raim_fde_design`. Throws a `TypeError` for malformed
+ * input and an `Error` for a rank-deficient or otherwise rejected set.
+ */
+export function raimFdeDesign(rows: any, options: any): any;
+
 /**
  * Convert a pseudorange rate in metres per second to Doppler shift in hertz.
  */
@@ -3695,12 +6170,64 @@ export function rinexBandFrequencyHz(system: GnssSystem, band: string, glonass_c
  */
 export function rinexBandWavelengthM(system: GnssSystem, band: string, glonass_channel?: number | null): number | undefined;
 
+/**
+ * Read the 12-bit RTCM message number from a message body.
+ *
+ * `body` is the bytes between the frame length word and CRC. Delegates to
+ * `sidereon_core::rtcm::message_number`.
+ */
+export function rtcmMessageNumber(body: Uint8Array): number;
+
 /**
  * Transform a 3x3 RTN covariance (flat row-major length 9) to ECI for the given
  * orbit state. Returns a flat row-major length-9 `Float64Array`.
  */
 export function rtnToEciCovariance(covariance_rtn: Float64Array, position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
 
+/**
+ * Convert an inertial Cartesian state to classical orbital elements.
+ *
+ * `r` is the ECI position (km), `v` the ECI velocity (km/s), and `mu` the
+ * gravitational parameter (km^3/s^2). Returns a `ClassicalElements` object;
+ * undefined primary angles and the inapplicable auxiliary angles are `NaN` per
+ * the orbit type. Delegates to `sidereon_core::astro::elements::rv2coe`. Throws
+ * a `TypeError` for a wrong-length vector and an `Error` for a degenerate or
+ * non-finite state.
+ */
+export function rv2coe(r: Float64Array, v: Float64Array, mu: number): any;
+
+/**
+ * Apparent visual magnitude of a sunlit body from a diffuse-sphere phase law.
+ *
+ * `rangeKm` and `referenceRangeKm` (both positive) are the observation range
+ * and the reference range at which `standardMagnitude` is defined;
+ * `phaseAngleDeg` is the solar phase angle (Sun-body-observer), clamped to
+ * `[0, 180]`. Delegates to
+ * `sidereon_core::astro::observation::satellite_visual_magnitude`.
+ */
+export function satelliteVisualMagnitude(range_km: number, phase_angle_deg: number, standard_magnitude: number, reference_range_km: number): number;
+
+/**
+ * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
+ *
+ * `primaryLine1` / `primaryLine2` is the primary TLE; `secondaries` is an array
+ * of `{ line1, line2 }`; `missDistanceThresholdKm` is the miss-distance cutoff.
+ * Returns one `TcaScreeningHit` (`{ secondaryIndex, candidate }`) per local TCA
+ * at or below the threshold, in catalog then time order. Delegates to
+ * `sidereon_core::astro::tca::screen_tca_candidates_from_tle_catalog_serial`.
+ */
+export function screenTcaCandidates(primary_line1: string, primary_line2: string, secondaries: any, window_start_unix_micros: bigint, window_end_unix_micros: bigint, miss_distance_threshold_km: number, options: any): any;
+
+/**
+ * Screen a primary against a secondary TLE catalog and evaluate collision
+ * probability at each threshold TCA.
+ *
+ * Like `screenTcaCandidates`, plus `pcOptions`. Returns an array of
+ * `TcaScreeningConjunctionHit` (`{ secondaryIndex, conjunction }`). Delegates to
+ * `sidereon_core::astro::tca::screen_tca_conjunctions_from_tle_catalog_serial`.
+ */
+export function screenTcaConjunctions(primary_line1: string, primary_line2: string, secondaries: any, window_start_unix_micros: bigint, window_end_unix_micros: bigint, miss_distance_threshold_km: number, pc_options: any, options: any): any;
+
 /**
  * Select an IONEX product usable at `requestedEpochJ2000S`, degrading to a
  * diurnal-shifted prior product within `policy`.
@@ -3763,6 +6290,65 @@ export function smoothIonoFreeCode(arc: any, options: any, hatch_window_cap?: nu
  */
 export function snrPostDb(cn0_dbhz: number, integration_time_s: number): number;
 
+/**
+ * Solid-earth pole tide displacement of an ITRF station, metres (ECEF).
+ *
+ * `stationEcefM` is a length-3 geocentric ECEF metre vector and the epoch is
+ * the UTC `year`/`month`/`day` plus `fractionalHour`. `xpArcsec` / `ypArcsec`
+ * are the polar-motion coordinates in arcseconds. Returns the displacement
+ * `[dx, dy, dz]`. Delegates to `sidereon_core::tides::solid_earth_pole_tide`.
+ */
+export function solidEarthPoleTide(station_ecef_m: Float64Array, year: number, month: number, day: number, fractional_hour: number, xp_arcsec: number, yp_arcsec: number): Float64Array;
+
+/**
+ * Solid-earth tide displacement of an ITRF station, metres (ECEF).
+ *
+ * `stationEcefM`, `sunEcefM`, `moonEcefM` are length-3 geocentric ECEF metre
+ * vectors. The epoch is the UTC `year`/`month`/`day` plus `fractionalHour`
+ * (`hour + min/60 + sec/3600`, in `[0, 24)`). Returns the displacement
+ * `[dx, dy, dz]`. Delegates to `sidereon_core::tides::solid_earth_tide`.
+ */
+export function solidEarthTide(station_ecef_m: Float64Array, year: number, month: number, day: number, fractional_hour: number, sun_ecef_m: Float64Array, moon_ecef_m: Float64Array): Float64Array;
+
+/**
+ * Solve a sequence of moving-baseline RTK epochs.
+ *
+ * `config` is a plain object; see the `MovingBaselineConfig` TypeScript type.
+ * Each epoch is solved independently against its own `basePositionM`; with
+ * `warmStart` (default `true`) each solved baseline seeds the next epoch's
+ * linearization point. Returns an array of `MovingBaselineEpochSolution`. Throws
+ * a `TypeError` for malformed input and an `Error` if a solve fails (the message
+ * names the failing epoch index). Delegates to
+ * `sidereon_core::rtk_filter::moving_baseline::solve_moving_baseline`.
+ */
+export function solveMovingBaseline(config: any): MovingBaselineSolution[];
+
+/**
+ * Solve a static integer-fixed PPP arc from raw epochs: SPP auto-init seed, the
+ * float solve, then the LAMBDA integer fix and ambiguity-conditioned re-solve.
+ *
+ * `epochs`, `floatConfig`, and `fixedConfig` are the same plain objects the
+ * float and fixed solves take; `options` is an optional `PppAutoInitOptions`
+ * object. Delegates to
+ * `sidereon_core::precise_positioning::auto_init::solve_ppp_auto_init_fixed`.
+ * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solvePppAutoInitFixed(sp3: Sp3, epochs: any, options: any, float_config: any, fixed_config: any): PppFixedSolution;
+
+/**
+ * Solve a static multi-epoch float PPP arc from raw epochs, auto-initializing
+ * the float state from the SPP seed.
+ *
+ * Unlike [`solvePppFloat`], the caller does not supply an initial state: the
+ * driver seeds it (per-epoch SPP code solve, mean position, phase-minus-code
+ * ambiguities) before the float solve. `epochs` and `config` are the same plain
+ * objects [`solvePppFloat`] takes; `options` is an optional `PppAutoInitOptions`
+ * object (pass `undefined` for the SPP-seeded defaults). Delegates to
+ * `sidereon_core::precise_positioning::auto_init::solve_ppp_auto_init_float`.
+ * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solvePppAutoInitFloat(sp3: Sp3, epochs: any, options: any, config: any): PppFloatSolution;
+
 /**
  * Search integer ambiguities from a float PPP solution and re-solve fixed.
  *
@@ -3781,6 +6367,18 @@ export function solvePppFixed(sp3: Sp3, epochs: any, float_solution: PppFloatSol
  */
 export function solvePppFloat(sp3: Sp3, epochs: any, initial_state: any, config: any): PppFloatSolution;
 
+/**
+ * Solve a sequential RTK baseline arc from raw rover+base epochs.
+ *
+ * `epochs` is an array of `RtkArcEpoch` objects and `config` an `RtkArcConfig`
+ * object (see the TypeScript types). Returns `{ references, epochs, finalState }`:
+ * one reported baseline/ambiguity solution per input epoch, the per-system
+ * reference satellites selected once for the whole arc, and the final carried
+ * filter state. Delegates to `sidereon_core::rtk_filter::arc::solve_rtk_arc`.
+ * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solveRtkArc(epochs: any, config: any): any;
+
 /**
  * Solve a static fixed RTK baseline with residual validation / FDE.
  *
@@ -3798,12 +6396,29 @@ export function solveRtkFixed(config: any): RtkFixedSolution;
 export function solveRtkFloat(config: any): RtkFloatSolution;
 
 /**
- * Solve receiver ECEF velocity and clock drift from one epoch of observations.
- * `observations` is an array of `{ satelliteId, value, carrierHz,
- * satClockDriftSS? }`; `receiverEcefM` is a length-3 `Float64Array`.
+ * Solve a static RTK arc with one batch float solution and one validated fixed
+ * solution over the whole arc.
+ *
+ * `epochs` is an array of `RtkArcEpoch` objects and `config` a
+ * `RtkStaticArcConfig` object. Delegates to
+ * `sidereon_core::rtk_filter::arc::solve_static_rtk_arc`.
+ */
+export function solveStaticRtkArc(epochs: any, config: any): any;
+
+/**
+ * Solve receiver velocity over an SP3 precise product. See
+ * [`solveVelocityBroadcast`] for the broadcast-ephemeris counterpart.
  */
 export function solveVelocity(sp3: Sp3, observations: any, receiver_ecef_m: Float64Array, t_rx_j2000_s: number, options: any): VelocitySolution;
 
+/**
+ * Solve receiver ECEF velocity and clock drift from one epoch of observations
+ * over a broadcast ephemeris store. Identical to [`solveVelocity`] except the
+ * satellite states come from broadcast records. Delegates to
+ * `sidereon_core::velocity::solve`.
+ */
+export function solveVelocityBroadcast(broadcast: BroadcastEphemeris, observations: any, receiver_ecef_m: Float64Array, t_rx_j2000_s: number, options: any): VelocitySolution;
+
 /**
  * Solve a receiver position, preferring precise SP3 products and falling back to
  * broadcast ephemeris, reporting which source was used and how stale it is.
@@ -3817,6 +6432,33 @@ export function solveVelocity(sp3: Sp3, observations: any, receiver_ecef_m: Floa
  */
 export function solveWithFallback(precise: Sp3[], broadcast: BroadcastEphemeris, request: any, policy: any): SourcedSolution;
 
+/**
+ * Continuous seconds since J2000 for a split Julian date.
+ */
+export function splitJdToJ2000Seconds(jd_whole: number, jd_fraction: number): number;
+
+/**
+ * Sub-observer point (planetary central meridian) on a rotating body.
+ *
+ * `observerFromBody` is the observer position relative to the body center
+ * (length-3 `Float64Array`) in an inertial (ICRF/J2000 equatorial) frame, and
+ * `poleRaDeg` / `poleDecDeg` / `primeMeridianDeg` are the IAU WGCCRE pole right
+ * ascension, declination, and prime-meridian angle. Returns the body-fixed
+ * `{ latitudeDeg, longitudeDeg }` (planetocentric, longitude on `(-180, 180]`).
+ * Delegates to `sidereon_core::astro::observation::sub_observer_point`.
+ */
+export function subObserverPoint(observer_from_body: Float64Array, pole_ra_deg: number, pole_dec_deg: number, prime_meridian_deg: number): any;
+
+/**
+ * Sub-solar point: the geographic point where the Sun is at the zenith.
+ *
+ * `sunEcef` is the geocentric Sun position (length-3 `Float64Array`) in an
+ * Earth-fixed (ITRS/ECEF) frame; only its direction matters. Returns
+ * `{ latitudeDeg, longitudeDeg }` (geocentric, degrees). Delegates to
+ * `sidereon_core::astro::observation::sub_solar_point`.
+ */
+export function subSolarPoint(sun_ecef: Float64Array): any;
+
 /**
  * Angle in degrees between satellite nadir and the Sun direction.
  */
@@ -3848,11 +6490,45 @@ export function sunMoonEci(epochs_unix_us: BigInt64Array): SunMoon;
  */
 export function temeToGcrs(position_km: Float64Array, velocity_km_s: Float64Array, epochs_unix_us: BigInt64Array, skyfield_compat?: boolean | null): FrameStates;
 
+/**
+ * Latitude (degrees) of the day-night terminator at a query longitude.
+ *
+ * `subSolarLatitudeDeg` / `subSolarLongitudeDeg` are the sub-solar point (see
+ * `subSolarPoint`); `longitudeDeg` is the query longitude. Delegates to
+ * `sidereon_core::astro::observation::terminator_latitude_deg`.
+ */
+export function terminatorLatitudeDeg(sub_solar_latitude_deg: number, sub_solar_longitude_deg: number, longitude_deg: number): number;
+
 /**
  * Short uppercase identifier for a time scale, e.g. `"GPST"`.
  */
 export function timeScaleAbbrev(scale: TimeScale): string;
 
+/**
+ * Leap-aware inter-system offset `to_reading - from_reading`, in seconds, at a
+ * given UTC instant. Add the result to a `from`-scale reading to get the
+ * `to`-scale reading.
+ *
+ * `utcJd` is the UTC Julian date of the instant; it is consulted only to
+ * resolve the leap-second count when `from` or `to` is UTC-based
+ * (`Utc`/`Glonasst`), and is ignored for purely atomic pairs. Throws a
+ * `RangeError` for `Tdb` or a non-finite `utcJd` when a leap count is needed.
+ */
+export function timescaleOffsetAtS(from: TimeScale, to: TimeScale, utc_jd: number): number;
+
+/**
+ * Fixed inter-system offset `to_reading - from_reading`, in seconds, for the
+ * same physical instant. Add the result to a `from`-scale reading to get the
+ * `to`-scale reading.
+ *
+ * Covers the atomic scales (TAI/TT/GPST/GST/QZSST/BDT), whose mutual offsets
+ * are constants fixed by their ICDs. Throws a `RangeError` when either scale is
+ * UTC-based (`Utc`/`Glonasst`) — those carry leap seconds, so their offset is
+ * epoch-dependent and needs [`timescaleOffsetAtS`] — or for `Tdb` (no fixed
+ * offset; resolve it through an `Instant`).
+ */
+export function timescaleOffsetS(from: TimeScale, to: TimeScale): number;
+
 /**
  * Export records as the compact mapping CSV (`prn,norad_cat_id,active,sp3_id`).
  *
@@ -3912,6 +6588,25 @@ export function validate(records: any): any;
  */
 export function validateAgainstSp3Ids(records: any, ids: any): any;
 
+/**
+ * Satellites visible above `minElevationDeg` from `station` at a single instant,
+ * from already-initialized [`Tle`]s: the opsmode-preserving constellation
+ * snapshot.
+ *
+ * Each `Tle` in `satellites` carries the opsmode it was constructed with, so a
+ * deep-space / opsmode-sensitive object is evaluated in its own mode (unlike the
+ * element-based core path, which hardcodes AFSPC). `ids` supplies the identity
+ * out-of-band: `ids[i]` (a catalog number, name, or anything) becomes the
+ * `catalogNumber` of `satellites[i]`, so the two arrays must be the same length.
+ * The `Tle` instances are consumed by this call.
+ *
+ * `epochUnixUs` is a unix-microsecond UTC `bigint`. Per-satellite propagation or
+ * frame failures are skipped; the result is filtered by `minElevationDeg` and
+ * sorted by elevation descending. Throws an `Error` on an invalid station,
+ * elevation threshold, or `ids`/`satellites` length mismatch.
+ */
+export function visibleFromSatellites(satellites: Tle[], ids: string[], station: GroundStation, epoch_unix_us: bigint, min_elevation_deg: number): VisibleSatellite[];
+
 /**
  * Wavelength, metres, for frequency in Hz.
  */