@neilberkman/sidereon 0.8.1 → 0.9.1

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.
  */
@@ -988,6 +1367,37 @@ export class Ephemeris {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * A confidence ellipse from a 2x2 covariance block: semi-axes scaled by the
+ * two-degree-of-freedom chi-square quantile `-2 ln(1 - confidence)`.
+ */
+export class ErrorEllipse2 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Two-degree-of-freedom chi-square scale `-2 ln(1 - confidence)`.
+     */
+    readonly chiSquareScale: number;
+    /**
+     * Requested confidence probability in `(0, 1)`.
+     */
+    readonly confidence: number;
+    /**
+     * Semi-major-axis orientation in radians, from the first (row/col 0) axis
+     * toward the second (row/col 1) axis.
+     */
+    readonly orientationRad: number;
+    /**
+     * Semi-major axis length (same unit as the square root of the covariance).
+     */
+    readonly semiMajor: number;
+    /**
+     * Semi-minor axis length.
+     */
+    readonly semiMinor: number;
+}
+
 /**
  * A fault-detection-and-exclusion result: the surviving solution, the excluded
  * satellites in exclusion order, and the number of exclusions performed.
@@ -1027,65 +1437,191 @@ 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.
+     * Number of epochs each satellite was propagated to (the second axis).
      */
-    readonly accelerationMS2: Float64Array;
+    readonly epochCount: number;
     /**
-     * Broadcast clock bias, seconds.
+     * TEME positions, km, flat row-major `(satelliteCount, epochCount, 3)`,
+     * length `3 * satelliteCount * epochCount`.
      */
-    readonly clockBiasS: number;
+    readonly positionKm: Float64Array;
     /**
-     * FDMA frequency-channel number.
+     * Number of satellites in the fleet (the leading axis).
      */
-    readonly freqChannel: number;
+    readonly satelliteCount: number;
     /**
-     * Relative frequency offset.
+     * TEME velocities, km/s, flat row-major `(satelliteCount, epochCount, 3)`,
+     * length `3 * satelliteCount * epochCount`.
      */
-    readonly gammaN: number;
+    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;
     /**
-     * PZ-90.11 ECEF position `[x, y, z]`, metres.
+     * Begin scanning `bytes` from the start.
      */
-    readonly positionM: Float64Array;
+    constructor(bytes: Uint8Array);
     /**
-     * RINEX satellite token such as `"R10"`.
+     * 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 satellite: string;
+    next(): any;
     /**
-     * Satellite health; 0 is healthy.
+     * The total number of CRC-valid frames the scan found.
      */
-    readonly svHealth: number;
-    /**
-     * Reference epoch, UTC seconds past J2000.
+    readonly length: number;
+}
+
+/**
+ * A batch of transformed states from [`temeToGcrs`]: flat row-major
+ * `positionKm` and `velocityKmS` `Float64Array`s, each length `3 * epochCount`.
+ */
+export class FrameStates {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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;
     /**
@@ -1094,6 +1630,35 @@ export class GlonassRecordJs {
     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.
  */
@@ -1128,6 +1693,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 +1781,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 +1908,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 +1969,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 +2112,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 +2182,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.
  */
@@ -1512,6 +2224,95 @@ export class LeapSecondTable {
     readonly source: string;
 }
 
+/**
+ * A serial leave-one-out sweep: the base solve over all rows plus one re-solve
+ * per masked row, with the per-row optimum-cost shift.
+ */
+export class LeastSquaresDropOneReport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The solve with residual row `index` masked out. Throws a `RangeError` for
+     * an out-of-range index.
+     */
+    dropAt(index: number): LeastSquaresResult;
+    /**
+     * The solve over the full residual.
+     */
+    readonly base: LeastSquaresResult;
+    /**
+     * `costDeltas[i] = dropAt(i).cost - base.cost`: how much the optimum cost
+     * moves when row `i` is removed. `Float64Array` of length `count`.
+     */
+    readonly costDeltas: Float64Array;
+    /**
+     * Number of masked-row re-solves (equals the residual-row count `m`).
+     */
+    readonly count: number;
+}
+
+/**
+ * The outcome of one trust-region least-squares solve, mirroring the fields of
+ * `scipy.optimize.least_squares`'s `OptimizeResult`.
+ */
+export class LeastSquaresResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Optimal cost `0.5 * sum(residual^2)` (after robust reweighting when a
+     * non-linear loss is used).
+     */
+    readonly cost: number;
+    /**
+     * Residual vector at the solution, `Float64Array` of length `m`.
+     */
+    readonly fun: Float64Array;
+    /**
+     * Gradient `J^T f` at the solution, `Float64Array` of length `n`.
+     */
+    readonly grad: Float64Array;
+    /**
+     * Row-major `m`-by-`n` Jacobian at the solution, flat `Float64Array` of
+     * length `m * n`.
+     */
+    readonly jac: Float64Array;
+    /**
+     * Residual row count `m`.
+     */
+    readonly m: number;
+    /**
+     * Parameter count `n`.
+     */
+    readonly n: number;
+    /**
+     * Number of residual evaluations.
+     */
+    readonly nfev: number;
+    /**
+     * Number of Jacobian evaluations.
+     */
+    readonly njev: number;
+    /**
+     * First-order optimality `||J^T f||_inf` at the solution.
+     */
+    readonly optimality: number;
+    /**
+     * SciPy-compatible termination status: `0` max evaluations, `1` gtol,
+     * `2` ftol, `3` xtol, `4` both ftol and xtol.
+     */
+    readonly status: number;
+    /**
+     * Whether the solve converged (`status > 0`).
+     */
+    readonly success: boolean;
+    /**
+     * Solution parameter vector, `Float64Array` of length `n`.
+     */
+    readonly x: Float64Array;
+}
+
 /**
  * Link-budget inputs for [`LinkBudget.margin`].
  */
@@ -1550,46 +2351,291 @@ 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;
+    readonly cis: number;
+    /**
+     * Cosine harmonic correction to orbit radius, metres.
+     */
+    readonly crc: number;
+    /**
+     * Sine harmonic correction to orbit radius, metres.
+     */
+    readonly crs: number;
+    /**
+     * Cosine harmonic correction to argument of latitude, radians.
+     */
+    readonly cuc: number;
+    /**
+     * Sine harmonic correction to argument of latitude, radians.
+     */
+    readonly cus: number;
+    /**
+     * Mean motion difference, radians per second.
+     */
+    readonly deltaN: number;
+    /**
+     * Eccentricity.
+     */
+    readonly eccentricity: number;
+    /**
+     * Fit-interval flag.
+     */
+    readonly fitIntervalFlag: number;
+    /**
+     * Inclination at reference time, radians.
+     */
+    readonly i0: number;
+    /**
+     * Rate of inclination, radians per second.
+     */
+    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 refined Moon elevation threshold crossing (moonrise / moonset).
+ */
+export class MoonElevationCrossing {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     */
+    readonly elevationDeg: number;
+    /**
+     * Crossing direction: `"rising"` (moonrise) or `"setting"` (moonset).
+     */
+    readonly kind: string;
+    /**
+     * Refined crossing instant, unix microseconds.
+     */
+    readonly timeUnixUs: bigint;
+}
+
+/**
+ * One refined Moon meridian transit (culmination).
+ */
+export class MoonTransit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     */
+    readonly elevationDeg: number;
+    /**
+     * Culmination kind: `"upper"` (due south, highest) or `"lower"` (due north,
+     * lowest).
+     */
+    readonly kind: string;
+    /**
+     * Refined culmination instant, unix microseconds.
+     */
+    readonly timeUnixUs: bigint;
+}
+
+/**
+ * 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;
 }
 
 /**
@@ -1836,6 +2882,193 @@ export class ObservationValueSeries {
     readonly values: Float64Array;
 }
 
+/**
+ * A canonical, format-agnostic CCSDS Orbit Ephemeris Message parsed from KVN or
+ * XML.
+ */
+export class Oem {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OEM from one or more segments. `meta` carries the optional header
+     * fields (`ccsdsOemVers`, `creationDate`, `originator`).
+     */
+    constructor(segments: OemSegment[], meta: any);
+    /**
+     * Encode this OEM to CCSDS OEM KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Encode this OEM to CCSDS OEM XML text.
+     */
+    toXmlString(): string;
+    /**
+     * CCSDS OEM version string.
+     */
+    readonly ccsdsOemVers: string;
+    /**
+     * Creation date.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Originator.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Number of segments.
+     */
+    readonly segmentCount: number;
+    /**
+     * Metadata/data segments in message order.
+     */
+    readonly segments: OemSegment[];
+    /**
+     * Forgiving-parse count of ephemeris data lines skipped as malformed (KVN
+     * only; 0 for a constructed or XML-parsed message).
+     */
+    readonly skippedStates: number;
+}
+
+/**
+ * One OEM covariance block.
+ */
+export class OemCovariance {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    constructor(epoch: string, matrix: Float64Array, cov_ref_frame?: string | null);
+    /**
+     * Covariance reference-frame label, or `undefined`.
+     */
+    readonly covRefFrame: string | undefined;
+    /**
+     * Epoch text.
+     */
+    readonly epoch: string;
+    /**
+     * The 6x6 state covariance as a length-36 row-major `Float64Array`.
+     */
+    readonly matrix: Float64Array;
+}
+
+/**
+ * OEM segment metadata: object identity, frame, time system, and span.
+ */
+export class OemMetadata {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build OEM segment metadata. The seven leading arguments are required;
+     * `meta` carries the optional fields (`useableStartTime`, `useableStopTime`,
+     * `interpolation`, `interpolationDegree`).
+     */
+    constructor(object_name: string, object_id: string, center_name: string, ref_frame: string, time_system: string, start_time: string, stop_time: string, meta: any);
+    /**
+     * Center name.
+     */
+    readonly centerName: string;
+    /**
+     * Interpolation method label, or `undefined`.
+     */
+    readonly interpolation: string | undefined;
+    /**
+     * Interpolation polynomial degree, or `undefined`.
+     */
+    readonly interpolationDegree: number | undefined;
+    /**
+     * Object id (COSPAR international designator).
+     */
+    readonly objectId: string;
+    /**
+     * Object name.
+     */
+    readonly objectName: string;
+    /**
+     * Reference frame.
+     */
+    readonly refFrame: string;
+    /**
+     * Segment start time text.
+     */
+    readonly startTime: string;
+    /**
+     * Segment stop time text.
+     */
+    readonly stopTime: string;
+    /**
+     * Time system.
+     */
+    readonly timeSystem: string;
+    /**
+     * Useable start time text, or `undefined`.
+     */
+    readonly useableStartTime: string | undefined;
+    /**
+     * Useable stop time text, or `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.
  */
@@ -1905,102 +3138,455 @@ export class Omm {
      */
     readonly inclinationDeg: number;
     /**
-     * Mean anomaly, degrees.
+     * 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;
+    /**
+     * Time system.
+     */
+    readonly timeSystem: string | undefined;
+}
+
+/**
+ * UTC calendar epoch carried by an OMM `EPOCH` field.
+ */
+export class OmmEpoch {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OMM epoch from UTC calendar fields. Throws a `RangeError` on an
+     * out-of-range field.
+     */
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number, microsecond: number);
+    /**
+     * Calendar day.
+     */
+    readonly day: number;
+    /**
+     * Hour of day.
+     */
+    readonly hour: number;
+    /**
+     * ISO-8601 epoch text with microsecond precision.
+     */
+    readonly iso8601: string;
+    /**
+     * Microsecond of second.
+     */
+    readonly microsecond: number;
+    /**
+     * Minute of hour.
+     */
+    readonly minute: number;
+    /**
+     * Calendar month.
+     */
+    readonly month: number;
+    /**
+     * Second of minute.
+     */
+    readonly second: number;
+    /**
+     * Calendar year.
+     */
+    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.
      */
-    readonly meanAnomalyDeg: number;
+    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);
     /**
-     * Mean-element theory.
+     * Drag area, square metres.
      */
-    readonly meanElementTheory: string | undefined;
+    readonly dragAreaM2: number | undefined;
     /**
-     * Mean motion, rev/day.
+     * Drag coefficient.
      */
-    readonly meanMotion: number;
+    readonly dragCoeff: number | undefined;
     /**
-     * Second derivative of mean motion.
+     * Mass, kilograms.
      */
-    readonly meanMotionDdot: number;
+    readonly massKg: number | undefined;
     /**
-     * First derivative of mean motion.
+     * Solar-radiation-pressure area, square metres.
      */
-    readonly meanMotionDot: number;
+    readonly solarRadAreaM2: number | undefined;
     /**
-     * NORAD catalog number.
+     * Solar-radiation-pressure coefficient.
      */
-    readonly noradCatId: number;
+    readonly solarRadCoeff: number | undefined;
+}
+
+/**
+ * OPM Cartesian state vector at the message epoch.
+ */
+export class OpmState {
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * Object id.
+     * Build the OPM state. `epoch` is carried as text; `positionKm` and
+     * `velocityKmS` are length-3 `Float64Array`s in kilometres and km/s.
      */
-    readonly objectId: string | undefined;
+    constructor(epoch: string, position_km: Float64Array, velocity_km_s: Float64Array);
     /**
-     * Object name.
+     * Epoch text.
      */
-    readonly objectName: string | undefined;
+    readonly epoch: string;
     /**
-     * Originator.
+     * Position vector, kilometres, length-3 `Float64Array`.
      */
-    readonly originator: string | undefined;
+    readonly positionKm: Float64Array;
     /**
-     * Right ascension of the ascending node, degrees.
+     * Velocity vector, km/s, length-3 `Float64Array`.
      */
-    readonly raOfAscNodeDeg: number;
+    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;
     /**
-     * Reference frame.
+     * Number of satellites that parsed (length of `satellites`).
      */
-    readonly refFrame: string | undefined;
+    readonly count: number;
     /**
-     * Revolution number at epoch.
+     * The successfully parsed satellites, in file order, each as a `{ name, tle }`.
      */
-    readonly revAtEpoch: bigint;
+    readonly satellites: NamedTle[];
     /**
-     * Time system.
+     * How many complete `(line 1, line 2)` records were found but skipped
+     * because their element set failed SGP4 initialization.
      */
-    readonly timeSystem: string | undefined;
+    readonly skipped: number;
 }
 
 /**
- * UTC calendar epoch carried by an OMM `EPOCH` field.
+ * 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 OmmEpoch {
+export class PiecewiseOrbit {
+    private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Build an OMM epoch from UTC calendar fields. Throws a `RangeError` on an
-     * out-of-range field.
+     * 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`.
      */
-    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number, microsecond: number);
+    drift(truth: any, threshold_m: number): ReducedOrbitDrift;
     /**
-     * Calendar day.
+     * Sample an SP3 product and evaluate this piecewise model against those
+     * positions. Delegates to
+     * `sidereon_core::orbit::drift_piecewise_reduced_orbit_source`.
      */
-    readonly day: number;
+    driftSp3(sp3: Sp3, satellite: string, options: any): ReducedOrbitDrift;
     /**
-     * Hour of day.
+     * 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`.
      */
-    readonly hour: number;
+    driftTle(tle: Tle, options: any): ReducedOrbitDrift;
     /**
-     * ISO-8601 epoch text with microsecond precision.
+     * Evaluate the piecewise model position at `query` in `frame` (`"ecef"` or
+     * `"gcrs"`). Delegates to `sidereon_core::orbit::piecewise_position`.
      */
-    readonly iso8601: string;
+    position(query: any, frame: string): Float64Array;
     /**
-     * Microsecond of second.
+     * Evaluate the piecewise model position and velocity at `query` in `frame`.
+     * Delegates to `sidereon_core::orbit::piecewise_position_velocity`.
      */
-    readonly microsecond: number;
+    positionVelocity(query: any, frame: string): ReducedOrbitState;
     /**
-     * Minute of hour.
+     * 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.
      */
-    readonly minute: number;
+    segmentIndexAt(query: any): number;
     /**
-     * Calendar month.
+     * Model label, `"circular_secular"` or `"eccentric_secular"`.
      */
-    readonly month: number;
+    readonly model: string;
     /**
-     * Second of minute.
+     * Number of contiguous fitted segments.
      */
-    readonly second: number;
+    readonly segmentCount: number;
     /**
-     * Calendar year.
+     * Rounded segment length used to tile the requested window, seconds.
      */
-    readonly year: number;
+    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;
 }
 
 /**
@@ -2077,6 +3663,92 @@ export class PppFloatSolution {
     readonly ztdResidualM: number | undefined;
 }
 
+/**
+ * The per-request results of a batch observable prediction, index-aligned to
+ * the input requests. Each request independently either produced observables or
+ * failed; query a request with [`PredictBatch.isOk`] /
+ * [`PredictBatch.observables`] / [`PredictBatch.error`].
+ */
+export class PredictBatch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The failure message for request `index`, or `undefined` when it
+     * succeeded. Throws a `RangeError` for an out-of-range index.
+     */
+    error(index: number): string | undefined;
+    /**
+     * Whether request `index` produced observables. Throws a `RangeError` for
+     * an out-of-range index.
+     */
+    isOk(index: number): boolean;
+    /**
+     * The observables for request `index`. Throws a `RangeError` for an
+     * out-of-range index and an `Error` carrying that request's failure message
+     * when the prediction failed (check [`PredictBatch.isOk`] first).
+     */
+    observables(index: number): PredictedObservables;
+    /**
+     * Number of requests in the batch.
+     */
+    readonly count: number;
+}
+
+/**
+ * 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.
  */
@@ -2153,6 +3825,136 @@ export class RaimWeights {
     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 ReducedOrbitSourceFit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The fitted reduced-orbit model.
+     */
+    readonly orbit: ReducedOrbit;
+    /**
+     * Number of samples requested from the source.
+     */
+    readonly requestedSamples: number;
+    /**
+     * Number of source samples used by the fit.
+     */
+    readonly usedSamples: number;
+}
+
+/**
+ * Receiver model position and velocity from `positionVelocity`.
+ */
+export class ReducedOrbitState {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Model position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Model velocity `[vx, vy, vz]`, metres per second.
+     */
+    readonly velocityMS: Float64Array;
+}
+
 /**
  * A parsed RINEX clock product with satellite clock-bias interpolation.
  */
@@ -2174,6 +3976,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 +4027,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 +4270,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 +4331,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 +4362,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 +4481,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 +4586,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 +4727,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 +4766,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 +4789,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 +4875,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 +4898,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 +5130,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 +5210,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 +5269,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.
  */
@@ -3233,6 +5314,21 @@ export function collisionProbability(object1: ConjunctionState, object2: Conjunc
  */
 export function correlate(iq: Float64Array, prn: bigint, options: any): CorrelationResult;
 
+/**
+ * Fitted parameter covariance from a converged solve, scaling `(J^T J)^-1` by
+ * the post-fit reduced chi-square `s_sq = 2 * cost / (m - n)` (the same scale
+ * `scipy.optimize.curve_fit` applies to its `pcov`).
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array` (the Jacobian at the
+ * solution), and `cost` is the solve's optimal cost `0.5 * sum(residual^2)`;
+ * the degrees of freedom `m - n` (taken from the Jacobian's own shape) must be
+ * positive. Pairs naturally with a [`crate::LeastSquaresResult`] (`result.jac`,
+ * `result.m`, `result.n`, `result.cost`). Returns the `n`-by-`n` covariance as
+ * a flat row-major `Float64Array`. Delegates to
+ * `sidereon_core::astro::math::least_squares::covariance_from_jacobian`.
+ */
+export function covarianceFromJacobian(jacobian: Float64Array, m: number, n: number, cost: number): Float64Array;
+
 /**
  * Whether a 3x3 covariance (flat row-major length 9) is symmetric positive
  * semidefinite within the engine tolerance.
@@ -3245,6 +5341,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 +5361,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?,
@@ -3293,6 +5431,40 @@ export function diff(previous: any, current: any): any;
  */
 export function dishGain(diameter_m: number, frequency_hz: number, efficiency: number): number;
 
+/**
+ * GNSS dilution of precision with an explicit ENU convention for the
+ * horizontal/vertical split.
+ *
+ * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array` of ECEF unit
+ * vectors, `weights` a positive `Float64Array` of length `n`, and `convention`
+ * is `"geodeticNormal"` (the GNSS-standard default, matching [`gnssDop`]) or
+ * `"geocentricRadial"` (radial up). Only HDOP/VDOP differ between conventions
+ * (by ~`1e-3` relative); GDOP/PDOP/TDOP are identical. Delegates to
+ * `sidereon_core::geometry::dop_with_convention`.
+ */
+export function dopWithConvention(line_of_sight: Float64Array, weights: Float64Array, receiver: Wgs84Geodetic, convention: string): Dop;
+
+/**
+ * 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.
  */
@@ -3318,11 +5490,82 @@ export function ecefToGeodetic(position_km: Float64Array): Float64Array;
  */
 export function eclipseStatus(satellite_position_km: Float64Array, sun_position_km: Float64Array): string[];
 
+/**
+ * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
+ * orthometric height and a geodetic position in radians, using the embedded
+ * genuine EGM96 1-degree model. Delegates to
+ * `sidereon_core::geoid::egm96_ellipsoidal_height_m`.
+ */
+export function egm96EllipsoidalHeightM(orthometric_height_m: number, lat_rad: number, lon_rad: number): number;
+
+/**
+ * Orthometric height `H = h - N` (metres above mean sea level) from an
+ * ellipsoidal height and a geodetic position in radians, using the embedded
+ * genuine EGM96 1-degree model. Delegates to
+ * `sidereon_core::geoid::egm96_orthometric_height_m`.
+ */
+export function egm96OrthometricHeightM(ellipsoidal_height_m: number, lat_rad: number, lon_rad: number): number;
+
+/**
+ * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
+ * position in radians, from the embedded GENUINE EGM96 1-degree global grid.
+ * Latitude is positive north, longitude positive east. This is the recommended
+ * zero-setup default for metre-class datum work (its bilinear lookup agrees
+ * with the full 15-arcminute EGM96 grid to ~0.4 m RMS); the coarse
+ * [`geoidUndulation`] is only suitable for sanity checks. Delegates to
+ * `sidereon_core::geoid::egm96_undulation`.
+ */
+export function egm96Undulation(lat_rad: number, lon_rad: number): number;
+
 /**
  * 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`).
@@ -3335,6 +5578,126 @@ export function encounterFrame(position1_km: Float64Array, velocity1_km_s: Float
  */
 export function encounterPlaneCovariance(frame: EncounterFrame, covariance_km2: Float64Array): Float64Array;
 
+/**
+ * Confidence ellipse from an arbitrary 2x2 covariance block.
+ *
+ * `covariance` is a flat row-major length-4 `Float64Array` (`[c00, c01, c10,
+ * c11]`); `confidence` is in `(0, 1)`. The semi-axes are the eigenvalues of the
+ * symmetrized block scaled by the chi-square(2) quantile. Throws a `RangeError`
+ * for a non-positive-semidefinite block or an out-of-range confidence.
+ * Delegates to `sidereon_core::geometry::error_ellipse_2x2`.
+ */
+export function errorEllipse2(covariance: Float64Array, confidence: number): ErrorEllipse2;
+
+/**
+ * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
+ * window.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `startUnixUs` / `endUnixUs` bound the window in unix microseconds. `options`
+ * is `{ elevationThresholdDeg?, stepSeconds?, timeToleranceSeconds? }`.
+ * Delegates to `sidereon_core::astro::bodies::find_moon_elevation_crossings`.
+ */
+export function findMoonElevationCrossings(latitude_deg: number, longitude_deg: number, altitude_km: number, start_unix_us: bigint, end_unix_us: bigint, options: any): MoonElevationCrossing[];
+
+/**
+ * Find Moon meridian transits (upper and lower culminations) over a UTC window.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `startUnixUs` / `endUnixUs` bound the window in unix microseconds.
+ * `stepSeconds` is the uniform scan step and `timeToleranceSeconds` the
+ * refinement tolerance. Delegates to
+ * `sidereon_core::astro::bodies::find_moon_transits`.
+ */
+export function findMoonTransits(latitude_deg: number, longitude_deg: number, altitude_km: number, start_unix_us: bigint, end_unix_us: bigint, step_seconds: number, time_tolerance_seconds: number): MoonTransit[];
+
+/**
+ * Find local TCA candidates between two satellites over a UTC window.
+ *
+ * `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 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;
+
+/**
+ * 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 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;
+
+/**
+ * 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 fitPiecewiseReducedOrbit(samples: any, scale: TimeScale, model: string, t0: any, t1: any, segment_seconds: number): PiecewiseOrbit;
+
+/**
+ * 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 fitPiecewiseReducedOrbitSp3(sp3: Sp3, satellite: string, options: any): PiecewiseOrbitSourceFit;
+
+/**
+ * Sample a TLE/SGP4 source in UTC and fit a piecewise reduced orbit.
+ *
+ * `options` is `{ t0, t1, cadenceS, model, segmentSeconds }`. Delegates to
+ * `sidereon_core::orbit::fit_piecewise_reduced_orbit_source`.
+ */
+export function fitPiecewiseReducedOrbitTle(tle: Tle, options: any): PiecewiseOrbitSourceFit;
+
+/**
+ * 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 fitReducedOrbit(samples: any, scale: TimeScale, model: string): ReducedOrbit;
+
+/**
+ * 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 fitReducedOrbitSp3(sp3: Sp3, satellite: string, options: any): ReducedOrbitSourceFit;
+
+/**
+ * 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 fitReducedOrbitTle(tle: Tle, options: any): ReducedOrbitSourceFit;
+
+/**
+ * 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 fixWideLaneRtkArc(epochs: any, config: any): any;
+
 /**
  * J2 oblateness gravitational acceleration in km/s^2.
  *
@@ -3357,19 +5720,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)`.
  */
@@ -3382,46 +5779,159 @@ export function gamma(f1_hz: number, f2_hz: number): number;
 export function gcrsToItrs(position_km: Float64Array, epochs_unix_us: BigInt64Array, skyfield_compat?: boolean | null): Float64Array;
 
 /**
- * Convert a batch of geodetic coordinates to ITRS (ECEF).
- *
- * `geodetic` is a flat row-major `(n, 3)` `Float64Array` whose columns are
- * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Returns a flat `(n, 3)`
- * ITRS `Float64Array` in kilometres. Time-independent.
+ * Convert a batch of geodetic coordinates to ITRS (ECEF).
+ *
+ * `geodetic` is a flat row-major `(n, 3)` `Float64Array` whose columns are
+ * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Returns a flat `(n, 3)`
+ * ITRS `Float64Array` in kilometres. Time-independent.
+ */
+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.
+ *
+ * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array`; `weights` is a
+ * positive `Float64Array` of length `n`.
+ */
+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.
+ *
+ * `stationEcefM` is an ECEF metre vector (length 3); `j2000Seconds` is a
+ * `Float64Array` grid in the SP3 product time scale. Samples with too few
+ * satellites or singular geometry are omitted. `options` is
+ * `{ satellites?, elevationMaskDeg?=5, systems?, weighting?="unit", lightTime?=false }`.
+ */
+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"`.
+ */
+export function gnssSystemLabel(system: GnssSystem): string;
+
+/**
+ * Canonical RINEX one-letter identifier for a constellation, e.g. `"G"`.
+ */
+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 geodeticToEcef(geodetic: Float64Array): Float64Array;
+export function gnssVisible(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: number, options: any): GnssVisibleSatellite[];
 
 /**
- * Geometry-free phase combination `L_GF = L1 - L2`, metres.
+ * GPS - UTC (the GNSS leap-second offset since the GPS epoch) on a UTC calendar
+ * date: the IS-GPS-200 quantity broadcast in the navigation message (18 s from
+ * 2017-01-01). Equals `taiUtcOffsetS - 19`. Use this, not [`taiUtcOffsetS`],
+ * whenever you mean the leap seconds a GPS receiver applies. Delegates to
+ * `sidereon_core::astro::time::scales::gps_utc_offset_s`.
  */
-export function geometryFree(l1_m: number, l2_m: number): number;
+export function gpsUtcOffsetS(year: number, month: number, day: number): number;
 
 /**
- * GNSS dilution of precision from ECEF line-of-sight unit rows and weights.
+ * Trace of the Gauss-Newton Hessian approximation `J^T J`: the sum of the
+ * squared column norms of the Jacobian, with no inverse formed.
  *
- * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array`; `weights` is a
- * positive `Float64Array` of length `n`.
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array`. Delegates to
+ * `sidereon_core::astro::math::least_squares::hessian_trace`.
  */
-export function gnssDop(line_of_sight: Float64Array, weights: Float64Array, receiver: Wgs84Geodetic): Dop;
+export function hessianTrace(jacobian: Float64Array, m: number, n: number): number;
 
 /**
- * Sample SP3-derived GNSS DOP over a J2000 epoch grid.
+ * Gauss angles-only orbit determination.
  *
- * `stationEcefM` is an ECEF metre vector (length 3); `j2000Seconds` is a
- * `Float64Array` grid in the SP3 product time scale. Samples with too few
- * satellites or singular geometry are omitted. `options` is
- * `{ satellites?, elevationMaskDeg?=5, systems?, weighting?="unit", lightTime?=false }`.
+ * `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 gnssDopSeries(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: Float64Array, options: any): DopSeries;
+export function iodGaussAngles(decl: Float64Array, rtasc: Float64Array, jd: Float64Array, jdf: Float64Array, rseci: Float64Array): IodState;
 
 /**
- * Stable lower-case display label for a constellation, e.g. `"gps"`.
+ * 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 gnssSystemLabel(system: GnssSystem): string;
+export function iodGibbs(r1: Float64Array, r2: Float64Array, r3: Float64Array): IodVelocity;
 
 /**
- * Canonical RINEX one-letter identifier for a constellation, e.g. `"G"`.
+ * 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 gnssSystemLetter(system: GnssSystem): string;
+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 +5966,76 @@ 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;
+
+/**
+ * Jarque-Bera normality test on a residual set.
+ *
+ * `x` is a `Float64Array` (at least two values). Returns
+ * `{ statistic, pValue }` with `statistic = n/6 (S^2 + K^2/4)` (biased moments)
+ * and the chi-square(2) survival `pValue = exp(-statistic/2)`, matching
+ * `scipy.stats.jarque_bera`. Delegates to
+ * `sidereon_core::quality::normality::jarque_bera`.
+ */
+export function jarqueBera(x: Float64Array): any;
+
+/**
+ * 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;
+
+/**
+ * Sample kurtosis of a residual set.
+ *
+ * `x` is a `Float64Array`. `fisher` (default `true`) returns the excess
+ * kurtosis `m4 / m2^2 - 3` (Gaussian -> 0, `scipy.stats.kurtosis`); `false`
+ * returns the Pearson kurtosis (Gaussian -> 3). `bias` (default `true`); pass
+ * `false` for the sample correction (needs at least four values). Delegates to
+ * `sidereon_core::quality::normality::kurtosis`.
+ */
+export function kurtosis(x: Float64Array, fisher?: boolean | null, bias?: boolean | null): 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 +6052,87 @@ export function leapSeconds(year: number, month: number, day: number): number;
  */
 export function leapSecondsBatch(dates: Int32Array): Float64Array;
 
+/**
+ * Solve a generic data-driven least-squares problem.
+ *
+ * `request` is a `DataProblemInput` object: a `kind` (`"linear"`,
+ * `"polynomial"`, `"exponential"`) carrying its data arrays, the `x0` starting
+ * point, and the SciPy `least_squares` options. The whole trust-region
+ * iteration runs in Rust through
+ * `trust_region_least_squares::data::solve_data_problem` (the serial entry, the
+ * default in-crate SVD backend); no rayon thread pool is entered.
+ */
+export function leastSquares(request: any): LeastSquaresResult;
+
+/**
+ * Serial leave-one-out (jackknife) over a data-driven least-squares problem.
+ *
+ * Delegates to the core's serial leave-one-out entry
+ * `trust_region_least_squares::batch::solve_data_problem_drop_one_serial`: the
+ * full problem is solved once, then re-solved with each residual row masked in
+ * turn. The core's default `solve_data_problem_drop_one` fans these re-solves
+ * across a rayon pool that wasm has no threads for, so this binding takes the
+ * serial twin, which runs the identical re-solves one row at a time and is
+ * byte-identical to the parallel version.
+ */
+export function leastSquaresDropOne(request: any): LeastSquaresDropOneReport;
+
+/**
+ * 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.
@@ -3541,11 +6202,47 @@ export function mergeNavcen(records: any, statuses: any): any;
  */
 export function mergeSp3(sources: Sp3[], options: any): Sp3MergeResult;
 
+/**
+ * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
+ *
+ * `x` is a `Float64Array`; `fisher` and `bias` select the kurtosis convention
+ * and the bias correction exactly as in [`skewness`] / [`kurtosis`] (both
+ * default `true`). Returns `{ mean, variance, skewness, kurtosisExcess }`; the
+ * variance is the biased second central moment. Delegates to
+ * `sidereon_core::quality::normality::moments`.
+ */
+export function moments(x: Float64Array, fisher?: boolean | null, bias?: boolean | null): any;
+
 /**
  * Angle in degrees between satellite nadir and the Moon direction.
  */
 export function moonAngle(satellite_position_km: Float64Array, moon_position_km: Float64Array): Float64Array;
 
+/**
+ * Topocentric azimuth/elevation/range of the Moon from a ground site,
+ * including the diurnal parallax. See [`sunAzEl`] for the argument shapes.
+ * Delegates to `sidereon_core::astro::bodies::moon_az_el`.
+ */
+export function moonAzEl(latitude_deg: number, longitude_deg: number, altitude_km: number, epoch_unix_us: bigint): any;
+
+/**
+ * Topocentric geometric Moon (disk-center) elevation from a ground site,
+ * degrees. See [`sunAzEl`] for the argument shapes. Delegates to
+ * `sidereon_core::astro::bodies::moon_az_el` and returns its `elevationDeg`: the
+ * core `moon_elevation_deg` convenience wrapper `expect`s on the geometry, so a
+ * valid-shaped but out-of-range station (e.g. latitude 120) would panic the
+ * wasm module; going through `moon_az_el` surfaces that as a thrown JS error.
+ */
+export function moonElevationDeg(latitude_deg: number, longitude_deg: number, altitude_km: number, epoch_unix_us: bigint): number;
+
+/**
+ * Illuminated fraction of the Moon as seen from a ground site. Returns
+ * `{ illuminatedFraction, phaseAngleDeg }` (0 = new, 1 = full). See [`sunAzEl`]
+ * for the argument shapes. Delegates to
+ * `sidereon_core::astro::bodies::moon_illumination`.
+ */
+export function moonIllumination(latitude_deg: number, longitude_deg: number, altitude_km: number, epoch_unix_us: bigint): any;
+
 /**
  * Narrow-lane code combination, metres.
  */
@@ -3556,16 +6253,101 @@ 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;
 
+/**
+ * Parameter covariance from a design (Jacobian) matrix via the Gauss-Newton
+ * normal equations `varianceScale * (J^T J)^-1`, formed from the thin SVD of
+ * `J` (not by inverting `J^T J`, so the condition number is not squared).
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array` with `m >= n`;
+ * `varianceScale` (`sigma^2`, non-negative) scales the bare cofactor (pass the
+ * post-fit reduced chi-square for the fitted covariance, or `1.0` for
+ * `(J^T J)^-1`). Returns the `n`-by-`n` covariance as a flat row-major
+ * `Float64Array` of length `n * n`. Throws an `Error` for a rank-deficient
+ * Jacobian. Delegates to
+ * `sidereon_core::astro::math::least_squares::normal_covariance`.
+ */
+export function normalCovariance(jacobian: Float64Array, m: number, n: number, variance_scale: number): Float64Array;
+
+/**
+ * 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 +6366,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 +6393,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 +6448,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 +6468,73 @@ 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;
+
+/**
+ * Predict observables for many `(satellite, receiver, epoch)` requests from a
+ * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
+ * shapes. Delegates to the serial `sidereon_core::observables::predict_batch`.
+ */
+export function predictBatchBroadcast(broadcast: BroadcastEphemeris, satellites: string[], receivers_ecef_m: Float64Array, epochs_j2000_s: Float64Array, options: any): PredictBatch;
+
+/**
+ * Predict observables for many `(satellite, receiver, epoch)` requests from an
+ * SP3 precise product, serially.
+ *
+ * `satellites` is an array of satellite tokens, `receiversEcefM` a flat
+ * row-major `(n, 3)` `Float64Array` of receiver ECEF positions (metres), and
+ * `epochsJ2000S` a `Float64Array` of receive epochs (seconds since J2000); all
+ * three are index-aligned and length `n`. Element `i` of the result corresponds
+ * to request `i`. Delegates to the serial reference kernel
+ * `sidereon_core::observables::predict_batch`; the binding never spawns the
+ * rayon thread pool the parallel variant uses.
+ */
+export function predictBatchSp3(sp3: Sp3, satellites: string[], receivers_ecef_m: Float64Array, epochs_j2000_s: Float64Array, options: any): PredictBatch;
+
+/**
+ * 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 +6556,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 +6590,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`.
@@ -3737,12 +6684,32 @@ export function selectSp3OverRange(products: Sp3[], start_epoch_j2000_s: number,
  */
 export function shadowFraction(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
 
+/**
+ * Shapiro-Wilk normality test on a residual set.
+ *
+ * `x` is a `Float64Array` (at least three values). Returns `{ w, pValue }`,
+ * Royston's AS R94 port that `scipy.stats.shapiro` uses; `w` is in `(0, 1]`
+ * (closer to one is more Gaussian). Delegates to
+ * `sidereon_core::quality::normality::shapiro_wilk`.
+ */
+export function shapiroWilk(x: Float64Array): any;
+
 /**
  * Build satellite-keyed pseudorange sigmas in metres from `{ satelliteId,
  * elevationDeg, cn0Dbhz? }` entries. Invalid entries are dropped by the core.
  */
 export function sigmas(entries: any, options: any): SatelliteVector;
 
+/**
+ * Sample skewness of a residual set.
+ *
+ * `x` is a `Float64Array`. `bias` (default `true`) selects the Fisher-Pearson
+ * coefficient `g1 = m3 / m2^(3/2)` (`scipy.stats.skew`); `false` applies the
+ * sample correction (`scipy.stats.skew(bias=False)`, needs at least three
+ * values). Delegates to `sidereon_core::quality::normality::skewness`.
+ */
+export function skewness(x: Float64Array, bias?: boolean | null): number;
+
 /**
  * Stable lower-case label for a slip reason.
  */
@@ -3763,6 +6730,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 +6807,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 +6836,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,11 +6872,48 @@ 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.
  */
 export function sunAngle(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
 
+/**
+ * Topocentric azimuth/elevation/range of the Sun from a ground site.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `epochUnixUs` is the UTC instant as unix microseconds. Returns
+ * `{ azimuthDeg, elevationDeg, rangeKm }` (azimuth clockwise from north).
+ * Delegates to `sidereon_core::astro::bodies::sun_az_el`.
+ */
+export function sunAzEl(latitude_deg: number, longitude_deg: number, altitude_km: number, epoch_unix_us: bigint): any;
+
 /**
  * Sun elevation in degrees above the satellite local horizontal plane.
  */
@@ -3839,6 +6931,15 @@ export function sunMoonEcef(epochs_unix_us: BigInt64Array): SunMoon;
  */
 export function sunMoonEci(epochs_unix_us: BigInt64Array): SunMoon;
 
+/**
+ * TAI-UTC (cumulative leap seconds) in effect on a UTC calendar date.
+ *
+ * This is **not** the GNSS "GPS - UTC" offset; for the quantity a GPS receiver
+ * applies use [`gpsUtcOffsetS`] (they differ by a constant 19 s). Delegates to
+ * `sidereon_core::astro::time::scales::tai_utc_offset_s`.
+ */
+export function taiUtcOffsetS(year: number, month: number, day: number): number;
+
 /**
  * Transform a batch of TEME states to GCRS, each at its own epoch.
  *
@@ -3848,11 +6949,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 +7047,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.
  */