@neilberkman/sidereon 0.8.1 → 0.9.1

package/types/sidereon-extra.d.ts

@@ -34,6 +34,25 @@ export interface SppSurfaceMet {
   relativeHumidity: number;
 }
 
+/** Opt-in Huber/IRLS robust-reweighting tuning. Including the `robust` key on an
+ * SPP request (even as `{}`) enables the engine outer reweighting loop on top of
+ * the static elevation weighting; every field is optional and falls back to the
+ * engine default. Omitting `robust` runs the static reference solve unchanged. */
+export interface SppRobust {
+  /** Huber tuning constant `k`; residuals scaled below this keep full weight.
+   * Must be finite and positive. Defaults to the engine constant (~1.345). */
+  huberK?: number;
+  /** Floor (metres) on the MAD scale, so a near-perfect fit cannot down-weight
+   * every satellite. Must be finite and positive. Engine default applies. */
+  scaleFloorM?: number;
+  /** Maximum total outer solves (the warm start plus reweighted resolves). Must
+   * be at least 1. Engine default applies. */
+  maxOuter?: number;
+  /** Outer-loop position L2 step tolerance (metres). Must be finite and
+   * non-negative. Engine default applies. */
+  outerTolM?: number;
+}
+
 /** The object passed to `Sp3.solveSpp`. */
 export interface SppRequest {
   /** Pseudorange observations; at least one is required. */
@@ -64,6 +83,37 @@ export interface SppRequest {
   glonassChannels?: [number, number][];
   /** Populate WGS84 lat/lon/height in the result. Defaults to true. */
   withGeodetic?: boolean;
+  /** Opt-in Huber/IRLS robust reweighting. Omit for the static
+   * elevation-weighted reference solve; include (even as `{}`) to route through
+   * the engine outer reweighting loop. Honored on the SP3, broadcast-only, and
+   * fallback paths, since it is a property of the solve inputs. */
+  robust?: SppRobust;
+  /** Cold-start convergence-basin widening: the number of near-surface
+   * golden-spiral seeds the engine tries (plus `initialGuess`), selecting the
+   * best redundant converged fix. Must be at least 1. Omit for the single exact
+   * solve from `initialGuess`. Honored only by `Sp3.solveSpp` (the policy-bearing
+   * path), not the broadcast-only or fallback paths. */
+  coarseSearchSeeds?: number;
+  /** Optional positive PDOP ceiling: a fix whose geometry is rank-deficient or
+   * exceeds this ceiling is refused with an `Error`. Honored only by
+   * `Sp3.solveSpp`. */
+  maxPdop?: number;
+}
+
+/** Shared options for `Sp3.solveSppBatch(epochs, options)`, applied to every
+ * epoch of the batch. The batch shares one `withGeodetic` flag and one solve
+ * policy across all epochs (each epoch entry is itself an `SppRequest`, but its
+ * own `withGeodetic` / `maxPdop` / `coarseSearchSeeds` are ignored in favour of
+ * these). Every field is optional. */
+export interface SppBatchOptions {
+  /** Populate WGS84 lat/lon/height in each epoch's result. Defaults to true. */
+  withGeodetic?: boolean;
+  /** Cold-start convergence-basin widening applied to every epoch. Must be at
+   * least 1. Omit for the single exact solve from each epoch's `initialGuess`. */
+  coarseSearchSeeds?: number;
+  /** Positive PDOP ceiling applied to every epoch; a fix that exceeds it (or is
+   * rank-deficient) becomes that epoch's error. */
+  maxPdop?: number;
 }
 
 // --- Observable-domain plain-object inputs ----------------------------------
@@ -391,6 +441,16 @@ export interface PppMeasurementWeights {
   elevationWeighting?: boolean;
 }
 
+/** One VMF1 site-wise `a`-coefficient sample (00/06/12/18 UT node). */
+export interface VmfSiteSample {
+  /** Modified Julian date of the sample. */
+  mjd: number;
+  /** Hydrostatic `a` coefficient. */
+  ah: number;
+  /** Wet `a` coefficient. */
+  aw: number;
+}
+
 /** PPP troposphere controls. */
 export interface PppTroposphereOptions {
   enabled?: boolean;
@@ -398,6 +458,12 @@ export interface PppTroposphereOptions {
   pressureHpa?: number;
   temperatureK?: number;
   relativeHumidity?: number;
+  /**
+   * Vienna Mapping Function 1 site-wise `a`-coefficient series. When one or
+   * more strictly-ascending samples are supplied the zenith delays are mapped
+   * with VMF1; otherwise the climatological Niell (1996) mapping is used.
+   */
+  vmf1?: VmfSiteSample[];
 }
 
 /** Iteration and convergence controls for PPP. */
@@ -434,6 +500,133 @@ export interface PppFixedConfig {
   options?: PppFloatOptions;
 }
 
+// --- Static PPP correction precompute ---------------------------------------
+//
+// `pppCorrections(sp3, epochs, receiverEcefM, options?)` deserializes `epochs`
+// and `options` through serde and returns the correction tables as a plain
+// object (typed `any` by wasm-bindgen). Import:
+//
+//   import { pppCorrections } from "@neilberkman/sidereon";
+//   import type { PppCorrectionsOptions, PppCorrections } from "@neilberkman/sidereon/types";
+
+/** One satellite observation row (carrier frequencies) for the precompute. */
+export interface PppCorrectionObservation {
+  satelliteId: string;
+  freq1Hz: number;
+  freq2Hz: number;
+}
+
+/** One receiver epoch for the correction precompute: civil UTC date/time, the
+ * receive time as continuous seconds since J2000, and the visible-satellite rows. */
+export interface PppCorrectionEpoch {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  tRxJ2000S: number;
+  observations: PppCorrectionObservation[];
+}
+
+/** Solid-earth pole-tide options: the IERS polar motion of the date (arcsec),
+ * sourced from IERS EOP (the engine does not embed polar motion). */
+export interface PoleTideOptions {
+  xpArcsec: number;
+  ypArcsec: number;
+}
+
+/** Per-station ocean-loading BLQ coefficients (Bos-Scherneck / HARDISP format).
+ *
+ * `amplitudeM` (metres) and `phaseDeg` (degrees, positive lag) are each a
+ * `3 x 11` nested array indexed `[component][constituent]`: component order is
+ * radial/up (0), tangential EW/west (1), tangential NS/south (2); constituent
+ * order is the BLQ columns M2 S2 N2 K2 K1 O1 P1 Q1 Mf Mm Ssa. */
+export interface OceanLoadingBlq {
+  amplitudeM: number[][];
+  phaseDeg: number[][];
+}
+
+/** Frequency-dependent satellite antenna calibration. */
+export interface PppSatelliteAntennaFrequency {
+  label: string;
+  /** Body-frame phase-centre offset `[x, y, z]`, metres. */
+  pcoM: [number, number, number];
+  /** Nadir-angle no-azimuth PCV samples as `[nadirDeg, pcvM]` pairs. */
+  noaziPcvM: [number, number][];
+}
+
+/** One satellite's antenna block, selected by PRN and an optional validity window. */
+export interface PppSatelliteAntenna {
+  sat: string;
+  validFrom?: PppCivilDateTime;
+  validUntil?: PppCivilDateTime;
+  frequencies: PppSatelliteAntennaFrequency[];
+}
+
+/** Satellite-antenna correction options. */
+export interface PppSatelliteAntennaOptions {
+  freq1Label: string;
+  freq1Hz: number;
+  freq2Label: string;
+  freq2Hz: number;
+  antennas: PppSatelliteAntenna[];
+}
+
+/** The optional options object passed to `pppCorrections`. Omit a field to leave
+ * that correction off. */
+export interface PppCorrectionsOptions {
+  /** Compute the per-epoch solid-earth tide displacement. */
+  solidEarthTide?: boolean;
+  /** Compute the per-satellite carrier-phase wind-up. */
+  phaseWindup?: boolean;
+  /** Compute the satellite antenna PCO/PCV projection. */
+  satelliteAntenna?: PppSatelliteAntennaOptions;
+  /** Compute the solid-earth pole tide (needs the date's IERS polar motion). */
+  poleTide?: PoleTideOptions;
+  /** Compute ocean tide loading from the station's BLQ block. */
+  oceanLoading?: OceanLoadingBlq;
+}
+
+/** A per-epoch ECEF displacement correction. */
+export interface PppEpochVectorCorrection {
+  /** Index into the input `epochs` array. */
+  epochIndex: number;
+  /** ECEF displacement `[dx, dy, dz]`, metres. */
+  vectorM: [number, number, number];
+}
+
+/** A per-satellite, per-epoch scalar correction (metres). */
+export interface PppSatScalarCorrection {
+  sat: string;
+  epochIndex: number;
+  valueM: number;
+}
+
+/** A per-satellite, per-epoch ECEF vector correction (metres). */
+export interface PppSatVectorCorrection {
+  sat: string;
+  epochIndex: number;
+  vectorM: [number, number, number];
+}
+
+/** The correction tables returned by `pppCorrections`. Each list is keyed by the
+ * input epoch index; lists for corrections that were not requested are empty. */
+export interface PppCorrections {
+  /** Solid-earth tide displacement per epoch. */
+  tide: PppEpochVectorCorrection[];
+  /** Solid-earth pole-tide displacement per epoch. */
+  poleTide: PppEpochVectorCorrection[];
+  /** Ocean tide loading displacement per epoch. */
+  oceanLoading: PppEpochVectorCorrection[];
+  /** Carrier-phase wind-up per satellite per epoch, metres. */
+  windupM: PppSatScalarCorrection[];
+  /** Satellite antenna PCO projected into ECEF per satellite per epoch, metres. */
+  satPcoEcef: PppSatVectorCorrection[];
+  /** Satellite antenna nadir PCV per satellite per epoch, metres. */
+  satPcvM: PppSatScalarCorrection[];
+}
+
 // --- SP3 merge --------------------------------------------------------------
 //
 // `mergeSp3(sources, options?)` deserializes `options` through serde. Import:
@@ -496,14 +689,34 @@ export interface GnssDopSeriesOptions {
 //   import { Cdm, CdmObject } from "@neilberkman/sidereon";
 //   import type { CdmObjectMeta, CdmMeta } from "@neilberkman/sidereon/types";
 
-/** Optional metadata for a `CdmObject`. */
+/** Optional metadata for a `CdmObject`: the full CCSDS 508.0-B-1 object metadata
+ * block plus the optional RTN velocity-covariance rows. Every string field is the
+ * verbatim textual value; omitted fields are not emitted on encode. */
 export interface CdmObjectMeta {
   objectDesignator?: string;
   catalogName?: string;
   objectName?: string;
   internationalDesignator?: string;
   objectType?: string;
+  operatorContactPosition?: string;
+  operatorOrganization?: string;
+  operatorPhone?: string;
+  operatorEmail?: string;
+  ephemerisName?: string;
+  covarianceMethod?: string;
+  maneuverable?: string;
+  orbitCenter?: string;
   refFrame?: string;
+  gravityModel?: string;
+  atmosphericModel?: string;
+  nBodyPerturbations?: string;
+  solarRadPressure?: string;
+  earthTides?: string;
+  intrackThrust?: string;
+  /** RTN velocity-covariance rows completing the 6x6 matrix, a length-15 array in
+   * CCSDS order (`CRDOT_R` .. `CNDOT_NDOT`). Omit when only the position
+   * covariance block is carried. */
+  velocityCovarianceRtn?: number[];
 }
 
 /** Optional message-level fields for a `Cdm`. */
@@ -634,8 +847,9 @@ export interface FdeRequest {
 
 // --- Broadcast-vs-precise comparison ----------------------------------------
 //
-// `BroadcastEphemeris.compareToSp3(...)` returns a plain object typed `any`.
-// Import:
+// `BroadcastEphemeris.compareToSp3(...)` and the window-form
+// `BroadcastEphemeris.compareWindowToSp3(...)` both return a plain object typed
+// `any` with the `BroadcastCompareReport` shape below. Import:
 //
 //   import { loadRinexNav } from "@neilberkman/sidereon";
 //   import type { BroadcastCompareReport } from "@neilberkman/sidereon/types";
@@ -735,6 +949,9 @@ export interface ConstellationRecord {
   noradId: number;
   /** Canonical SP3/RINEX satellite token ("G03"). */
   sp3Id: string;
+  /** GLONASS FDMA L1/L2 frequency-channel number (`k`, in -7..=6); absent for
+   * the CDMA constellations. */
+  fdmaChannel?: number;
   /** Present in the base identity source. */
   active: boolean;
   /** Advisory usability flag. */
@@ -759,16 +976,23 @@ export interface NavcenStatus {
   clock?: string;
 }
 
+/** A `(system, prn)` pair. Findings are keyed by system so a legitimate
+ * multi-system catalog (GPS PRN 1 and Galileo PRN 1) is not a false collision. */
+export interface ConstellationSystemPrn {
+  system: ConstellationSystem;
+  prn: number;
+}
+
 /** The report returned by `validate` / `validateAgainstSp3Ids`. */
 export interface ConstellationValidation {
   /** Active+usable catalog SP3 ids absent from the compared product. */
   missingSp3Ids: string[];
-  /** PRNs that appear in more than one record. */
-  duplicatePrns: number[];
+  /** (system, PRN) pairs that appear in more than one record. */
+  duplicatePrns: ConstellationSystemPrn[];
   /** NORAD ids that appear in more than one record. */
   duplicateNoradIds: number[];
-  /** PRNs that are inactive or unusable. */
-  inactiveUnusablePrns: number[];
+  /** (system, PRN) pairs that are inactive or unusable. */
+  inactiveUnusablePrns: ConstellationSystemPrn[];
   /** SP3 ids in the product absent from the active+usable catalog. */
   extraSp3Ids: string[];
 }
@@ -790,10 +1014,31 @@ export interface ConstellationDiff {
   noradReassigned: ConstellationFieldChange<number>[];
   sp3IdChanged: ConstellationFieldChange<string>[];
   svnChanged: ConstellationFieldChange<number | null>[];
+  /** GLONASS FDMA frequency-channel corrections on a held slot. */
+  fdmaChannelChanged: ConstellationFieldChange<number | null>[];
   activityChanged: ConstellationFieldChange<boolean>[];
   usabilityChanged: ConstellationFieldChange<boolean>[];
 }
 
+/** An OMM entry `fromCelestrakJsonLenient` could not resolve to a record for the
+ * requested system, carrying its identity so the caller can triage the skip. */
+export interface SkippedOmm {
+  /** The OMM OBJECT_NAME, when present. */
+  objectName?: string;
+  /** The OMM NORAD_CAT_ID. */
+  noradId: number;
+}
+
+/** The result of `fromCelestrakJsonLenient`: the records that resolved for the
+ * requested system, plus the entries that did not. */
+export interface ConstellationCatalog {
+  /** Records built from resolvable entries, sorted by `(system, prn)`. */
+  records: ConstellationRecord[];
+  /** Entries whose OBJECT_NAME did not resolve to a PRN for the system, in
+   * input order. */
+  skipped: SkippedOmm[];
+}
+
 // --- Product-staleness selection + broadcast fallback -----------------------
 //
 // `selectIonex` / `selectSp3` (+ `*OverRange`) and `solveWithFallback` take an
@@ -894,3 +1139,1168 @@ export interface FixSource {
   staleness: StalenessMetadata | null;
   broadcastReason: BroadcastReason | null;
 }
+
+// --- Integer-ambiguity resolution (LAMBDA / bounded ILS) --------------------
+//
+// `lambdaIlsSearch(floatCycles, covariance, ratioThreshold)` and
+// `boundedIlsSearch(floatCycles, covariance, radius, candidateLimit,
+// ratioThreshold)` take the covariance as a row-major `number[][]` and return an
+// `IlsResult` object (typed `any` by wasm-bindgen). Import:
+//
+//   import { lambdaIlsSearch } from "@neilberkman/sidereon";
+//   import type { IlsResult } from "@neilberkman/sidereon/types";
+
+/** The outcome of an integer-least-squares search. */
+export interface IlsResult {
+  /** Best integer vector, parallel to the input `floatCycles`. Cycle counts are
+   * small integers and cross as plain numbers (not BigInt). */
+  fixed: number[];
+  /** Whether the ratio test passes at the requested threshold. */
+  fixedStatus: boolean;
+  /** Runner-up / best score ratio. Saturates to `Number.MAX_VALUE` when the best
+   * score is exactly zero with a positive runner-up; `0` when there is no
+   * runner-up. */
+  ratio: number;
+  /** Best (lowest) quadratic score. */
+  bestScore: number;
+  /** Runner-up score; absent when no second lattice point exists. */
+  secondBestScore?: number;
+  /** Number of lattice points evaluated. */
+  candidatesEvaluated: number;
+  /** Symmetrized covariance actually used, row-major. */
+  covariance: number[][];
+  /** Symmetrized inverse covariance, row-major. */
+  covarianceInverse: number[][];
+}
+
+// --- SP3-backed visibility geometry -----------------------------------------
+//
+// `gnssVisible(sp3, stationEcefM, j2000Seconds, options?)`,
+// `gnssVisibilitySeries(sp3, stationEcefM, startJ2000S, endJ2000S, stepSeconds,
+// options?)`, and `gnssPasses(...)` deserialize `options` through serde. The
+// returned classes (`GnssVisibleSatellite`, `GnssVisibilityCount`, `GnssPass`)
+// are in the generated types. Import:
+//
+//   import { gnssVisible } from "@neilberkman/sidereon";
+//   import type { GnssVisibilityOptions } from "@neilberkman/sidereon/types";
+
+/** Visibility filters shared by `gnssVisible`, `gnssVisibilitySeries`, and
+ * `gnssPasses`. All fields optional. */
+export interface GnssVisibilityOptions {
+  /** Minimum topocentric elevation, degrees. Defaults to 5. */
+  elevationMaskDeg?: number;
+  /** Constellation filter as RINEX letters/names (e.g. ["G", "E"]); omit to
+   * admit every constellation in the product. */
+  systems?: string[];
+}
+
+// --- Observable prediction --------------------------------------------------
+//
+// `observablesSp3(sp3, satellite, receiverEcefM, tRxJ2000S, options?)` and
+// `observablesBroadcast(broadcast, satellite, tRxJ2000S, receiverEcefM,
+// options?)` deserialize `options` through serde and return the generated
+// `PredictedObservables` class. `solveVelocityBroadcast` reuses
+// `VelocityObservation` / `VelocitySolveOptions` above. Import:
+//
+//   import { observablesSp3 } from "@neilberkman/sidereon";
+//   import type { ObservablePredictOptions } from "@neilberkman/sidereon/types";
+
+/** Options controlling observable prediction. All fields optional. */
+export interface ObservablePredictOptions {
+  /** Carrier frequency used to scale Doppler, hertz. Defaults to the GPS L1
+   * frequency. */
+  carrierHz?: number;
+  /** Apply fixed-point light-time / transmit-time correction. Defaults to true. */
+  lightTime?: boolean;
+  /** Apply Earth-rotation Sagnac correction. Defaults to true. */
+  sagnac?: boolean;
+}
+
+// --- Reduced-orbit fit/eval/drift -------------------------------------------
+//
+// `fitReducedOrbit(samples, scale, model)` deserializes `samples` through serde
+// and returns the generated `ReducedOrbit` class, whose `position(query, frame)`
+// / `positionVelocity(query, frame)` / `drift(truth, thresholdM)` methods take
+// the same epoch/sample shapes. `scale` is a `TimeScale` enum value; `model` and
+// `frame` are the string unions below. Import:
+//
+//   import { fitReducedOrbit } from "@neilberkman/sidereon";
+//   import type { ReducedOrbitSample } from "@neilberkman/sidereon/types";
+
+/** Reduced-orbit secular model selector. */
+export type ReducedOrbitModelKind = "circular_secular" | "eccentric_secular";
+
+/** Frame for reduced-orbit evaluation. */
+export type ReducedOrbitFrame = "ecef" | "gcrs";
+
+/** A civil calendar epoch, interpreted in the model's time scale. */
+export interface ReducedOrbitCalendarEpoch {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  /** Second of minute, fractional. */
+  second: number;
+}
+
+/** One ECEF position sample for `fitReducedOrbit` and `ReducedOrbit.drift`. */
+export interface ReducedOrbitSample {
+  epoch: ReducedOrbitCalendarEpoch;
+  /** ECEF X, metres. */
+  xM: number;
+  /** ECEF Y, metres. */
+  yM: number;
+  /** ECEF Z, metres. */
+  zM: number;
+}
+
+// --- Source-backed reduced-orbit fit/drift ----------------------------------
+//
+// `fitReducedOrbitSp3(sp3, satellite, options)` and
+// `fitReducedOrbitTle(tle, options)` sample the source over `options` and return
+// the generated `ReducedOrbitSourceFit` class. The fitted `orbit` exposes
+// `driftSp3(...)` and `driftTle(...)` methods using the drift options below.
+
+/** Sampling window for source-backed reduced-orbit calls. */
+export interface ReducedOrbitSourceSampling {
+  /** Inclusive sampling start in the source time scale. */
+  t0: ReducedOrbitCalendarEpoch;
+  /** Inclusive sampling end in the source time scale. */
+  t1: ReducedOrbitCalendarEpoch;
+  /** Sampling cadence, seconds. */
+  cadenceS: number;
+}
+
+/** Options for `fitReducedOrbitSp3` and `fitReducedOrbitTle`. */
+export interface ReducedOrbitSourceFitOptions extends ReducedOrbitSourceSampling {
+  model: ReducedOrbitModelKind;
+}
+
+/** Options for `ReducedOrbit.driftSp3` and `ReducedOrbit.driftTle`. */
+export interface ReducedOrbitSourceDriftOptions extends ReducedOrbitSourceSampling {
+  /** First crossing threshold, metres. */
+  thresholdM: number;
+}
+
+// --- Piecewise reduced-orbit fit/eval/drift ---------------------------------
+//
+// `fitPiecewiseReducedOrbit(samples, scale, model, t0, t1, segmentSeconds)` tiles
+// the `[t0, t1]` window (both `ReducedOrbitCalendarEpoch`) into
+// `segmentSeconds`-long segments, fits each independently, and returns the
+// generated `PiecewiseOrbit` class. Its `position(query, frame)` /
+// `positionVelocity(query, frame)` / `drift(truth, thresholdM)` /
+// `segmentIndexAt(query)` methods take the same `ReducedOrbitCalendarEpoch` /
+// `ReducedOrbitSample` / `ReducedOrbitFrame` shapes as the single-segment model.
+// `samples` is `ReducedOrbitSample[]`; `scale` is a `TimeScale` enum value;
+// `model` is `ReducedOrbitModelKind`.
+
+// `fitPiecewiseReducedOrbitSp3(sp3, satellite, options)` and
+// `fitPiecewiseReducedOrbitTle(tle, options)` sample the source over `options`
+// and return the generated `PiecewiseOrbitSourceFit` class. The fitted `orbit`
+// exposes `driftSp3(...)` and `driftTle(...)` methods using
+// `ReducedOrbitSourceDriftOptions`.
+
+/** Options for source-backed piecewise reduced-orbit fitting. */
+export interface PiecewiseReducedOrbitSourceFitOptions extends ReducedOrbitSourceFitOptions {
+  /** Segment length, seconds. */
+  segmentSeconds: number;
+}
+
+// --- GPS LNAV navigation-message codec --------------------------------------
+//
+// `lnavEncode(params, options)` deserializes both objects through serde and
+// returns the generated `LnavSubframes` class. Import:
+//
+//   import { lnavEncode } from "@neilberkman/sidereon";
+//   import type { LnavParams } from "@neilberkman/sidereon/types";
+
+/** LNAV clock/ephemeris parameters in engineering units, the per-field input to
+ * `lnavEncode`. Integer fields (week number, codes, health, IODC/IODE,
+ * fit-interval flag, AODO) take whole numbers; the scaled fields take floats in
+ * the documented physical units. */
+export interface LnavParams {
+  /** GPS week number. */
+  weekNumber: number;
+  /** L2 code indicator. */
+  l2Code: number;
+  /** L2 P data flag (encode-only; not recovered by `lnavDecode`). */
+  l2PDataFlag: number;
+  /** User range accuracy index. */
+  uraIndex: number;
+  /** SV health bits. */
+  svHealth: number;
+  /** Issue of data, clock. */
+  iodc: number;
+  /** Group delay differential, seconds. */
+  tgd: number;
+  /** Clock reference time, seconds. */
+  toc: number;
+  /** Clock bias coefficient, seconds. */
+  af0: number;
+  /** Clock drift coefficient, seconds per second. */
+  af1: number;
+  /** Clock drift-rate coefficient, seconds per second squared. */
+  af2: number;
+  /** Issue of data, ephemeris. */
+  iode: number;
+  /** Sine harmonic correction to orbit radius, metres. */
+  crs: number;
+  /** Mean motion difference, radians per second. */
+  deltaN: number;
+  /** Mean anomaly at reference time, radians. */
+  m0: number;
+  /** Cosine harmonic correction to argument of latitude, radians. */
+  cuc: number;
+  /** Eccentricity. */
+  eccentricity: number;
+  /** Sine harmonic correction to argument of latitude, radians. */
+  cus: number;
+  /** Square root of the semi-major axis, sqrt(metres). */
+  sqrtA: number;
+  /** Ephemeris reference time, seconds. */
+  toe: number;
+  /** Fit-interval flag. */
+  fitIntervalFlag: number;
+  /** Age of data offset. */
+  aodo: number;
+  /** Cosine harmonic correction to inclination, radians. */
+  cic: number;
+  /** Longitude of ascending node at weekly epoch, radians. */
+  omega0: number;
+  /** Sine harmonic correction to inclination, radians. */
+  cis: number;
+  /** Inclination at reference time, radians. */
+  i0: number;
+  /** Cosine harmonic correction to orbit radius, metres. */
+  crc: number;
+  /** Argument of perigee, radians. */
+  omega: number;
+  /** Rate of right ascension, radians per second. */
+  omegaDot: number;
+  /** Rate of inclination, radians per second. */
+  idot: number;
+}
+
+/** Optional TLM/HOW options for `lnavEncode`. Every field is an integer and
+ * defaults to 0 when omitted. */
+export interface LnavOptions {
+  /** Time-of-week count (17-bit). */
+  tow?: number;
+  /** Alert flag (1-bit). */
+  alert?: number;
+  /** Anti-spoof flag (1-bit). */
+  antiSpoof?: number;
+  /** Integrity status flag (1-bit). */
+  integrity?: number;
+  /** TLM message (14-bit). */
+  tlmMessage?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Classical orbital elements (rv2coe / coe2rv)
+// ---------------------------------------------------------------------------
+
+/** Geometric classification of a two-body orbit. */
+export type OrbitType =
+  | "ellipticalInclined"
+  | "ellipticalEquatorial"
+  | "circularInclined"
+  | "circularEquatorial";
+
+/**
+ * Classical (Keplerian) orbital elements in the Vallado convention. Returned by
+ * `rv2coe` and accepted by `coe2rv`. Angles are radians; `p` and `a` are km.
+ * Undefined primary angles and inapplicable auxiliary angles are `NaN`. For
+ * `coe2rv` only `p`, `ecc`, `incl`, `raan`, `argp`, and `nu` are required (an
+ * ordinary elliptical-inclined orbit); `orbitType` and the auxiliary angles
+ * default.
+ */
+export interface ClassicalElements {
+  /** Semi-latus rectum p = h^2 / mu, km. */
+  p: number;
+  /** Semi-major axis a, km (Infinity for a parabolic orbit). Output only. */
+  a?: number;
+  ecc: number;
+  incl: number;
+  raan: number;
+  argp: number;
+  nu: number;
+  /** Argument of latitude u = argp + nu, rad (circular inclined orbits). */
+  arglat?: number;
+  /** True longitude, rad (circular equatorial orbits). */
+  truelon?: number;
+  /** Longitude of perigee, rad (elliptical equatorial orbits). */
+  lonper?: number;
+  orbitType?: OrbitType;
+}
+
+/** An inertial Cartesian state, returned by `coe2rv`. */
+export interface CartesianState {
+  positionKm: [number, number, number];
+  velocityKmS: [number, number, number];
+}
+
+// ---------------------------------------------------------------------------
+// Observational-astronomy geometry
+// ---------------------------------------------------------------------------
+
+/** A point on a body surface, geocentric/planetocentric latitude and longitude. */
+export interface SurfacePoint {
+  /** Degrees on [-90, 90]. */
+  latitudeDeg: number;
+  /** Degrees on (-180, 180]. */
+  longitudeDeg: number;
+}
+
+// ---------------------------------------------------------------------------
+// RTCM 3.x decode
+// ---------------------------------------------------------------------------
+
+/** A 1005 / 1006 station antenna reference point. */
+export interface RtcmStationCoordinates {
+  type: "stationCoordinates";
+  messageNumber: number;
+  referenceStationId: number;
+  itrfRealizationYear: number;
+  gpsIndicator: boolean;
+  glonassIndicator: boolean;
+  galileoIndicator: boolean;
+  referenceStationIndicator: boolean;
+  ecefX: bigint;
+  singleReceiverOscillator: boolean;
+  reserved: boolean;
+  ecefY: bigint;
+  quarterCycleIndicator: number;
+  ecefZ: bigint;
+  /** Antenna height, raw 0.1 mm units (1006 only). */
+  antennaHeight?: number;
+  /** ECEF coordinates in metres. */
+  xM: number;
+  yM: number;
+  zM: number;
+  /** Antenna height in metres (1006 only). */
+  antennaHeightM?: number;
+}
+
+/** A 1007 / 1008 / 1033 antenna or receiver descriptor. */
+export interface RtcmAntennaDescriptor {
+  type: "antennaDescriptor";
+  messageNumber: number;
+  referenceStationId: number;
+  antennaDescriptor: string;
+  antennaSetupId: number;
+  antennaSerialNumber?: string;
+  receiverType?: string;
+  receiverFirmwareVersion?: string;
+  receiverSerialNumber?: string;
+}
+
+/** MSM common header. */
+export interface RtcmMsmHeader {
+  referenceStationId: number;
+  epochTime: number;
+  multipleMessage: boolean;
+  iods: number;
+  reserved: number;
+  clockSteering: number;
+  externalClock: number;
+  divergenceFreeSmoothing: boolean;
+  smoothingInterval: number;
+}
+
+/** One MSM satellite record (raw transmitted integers). */
+export interface RtcmMsmSatellite {
+  id: number;
+  roughRangeMs: number;
+  roughRangeMod1: number;
+  extendedInfo?: number;
+  roughPhaseRangeRateMS?: number;
+}
+
+/** One MSM signal record (raw transmitted integers). */
+export interface RtcmMsmSignal {
+  satelliteId: number;
+  signalId: number;
+  finePseudorange: number;
+  finePhaseRange: number;
+  lockTimeIndicator: number;
+  halfCycleAmbiguity: boolean;
+  cnr: number;
+  finePhaseRangeRate?: number;
+}
+
+/** An MSM4 / MSM7 multi-signal observation message. */
+export interface RtcmMsm {
+  type: "msm";
+  messageNumber: number;
+  /** GNSS constellation label, e.g. "gps", "glonass". */
+  system: string;
+  /** "msm4" or "msm7". */
+  kind: string;
+  header: RtcmMsmHeader;
+  satellites: RtcmMsmSatellite[];
+  signals: RtcmMsmSignal[];
+}
+
+/** A 1019 GPS broadcast ephemeris (raw transmitted integers). */
+export interface RtcmGpsEphemeris {
+  type: "gpsEphemeris";
+  messageNumber: number;
+  satelliteId: number;
+  weekNumber: number;
+  svAccuracy: number;
+  codeOnL2: number;
+  idot: number;
+  iode: number;
+  tOc: number;
+  aF2: number;
+  aF1: number;
+  aF0: number;
+  iodc: number;
+  cRs: number;
+  deltaN: number;
+  m0: bigint;
+  cUc: number;
+  eccentricity: bigint;
+  cUs: number;
+  sqrtA: bigint;
+  tOe: number;
+  cIc: number;
+  omega0: bigint;
+  cIs: number;
+  i0: bigint;
+  cRc: number;
+  omega: bigint;
+  omegaDot: number;
+  tGd: number;
+  svHealth: number;
+  l2PDataFlag: boolean;
+  fitInterval: boolean;
+}
+
+/** A 1020 GLONASS broadcast ephemeris (raw transmitted integers). */
+export interface RtcmGlonassEphemeris {
+  type: "glonassEphemeris";
+  messageNumber: number;
+  satelliteId: number;
+  frequencyChannel: number;
+  almanacHealth: boolean;
+  almanacHealthAvailability: boolean;
+  p1: number;
+  tK: number;
+  bNMsb: boolean;
+  p2: boolean;
+  tB: number;
+  xnDot: number;
+  xn: number;
+  xnDotDot: number;
+  ynDot: number;
+  yn: number;
+  ynDotDot: number;
+  znDot: number;
+  zn: number;
+  znDotDot: number;
+  p3: boolean;
+  gammaN: number;
+  mP: number;
+  mLNThird: boolean;
+  tauN: number;
+  deltaTauN: number;
+  eN: number;
+  mP4: boolean;
+  mFT: number;
+  mNT: number;
+  mM: number;
+  additionalDataAvailable: boolean;
+  nA: number;
+  tauC: bigint;
+  mN4: number;
+  mTauGps: number;
+  mLNFifth: boolean;
+  reserved: number;
+}
+
+/** A recognized-but-undecoded message, preserved verbatim. */
+export interface RtcmUnsupported {
+  type: "unsupported";
+  messageNumber: number;
+  /** Undecoded body bytes. */
+  body: number[];
+}
+
+/** The decoded RTCM 3 message IR, tagged by `type`. Returned by `decodeRtcm`. */
+export type RtcmMessage =
+  | RtcmMsm
+  | RtcmStationCoordinates
+  | RtcmAntennaDescriptor
+  | RtcmGpsEphemeris
+  | RtcmGlonassEphemeris
+  | RtcmUnsupported;
+
+/** A single decoded frame, returned by `decodeRtcmFrame`. */
+export interface RtcmDecodedFrame {
+  message: RtcmMessage;
+  /** Total frame length in bytes (preamble, length, body, CRC). */
+  frameLen: number;
+}
+
+/** One yielded frame from a `FrameScanner`. */
+export interface RtcmScannedFrame {
+  /** Message body (bytes between the length word and the CRC). */
+  body: Uint8Array;
+  frameLen: number;
+}
+
+// ---------------------------------------------------------------------------
+// Moving-baseline RTK
+// ---------------------------------------------------------------------------
+
+/** One moving-baseline epoch: a per-epoch base ECEF position plus an RTK epoch. */
+export interface MovingBaselineEpoch extends RtkEpoch {
+  /** Base receiver ECEF position [x, y, z] this epoch, metres. */
+  basePositionM: [number, number, number];
+}
+
+/** The object passed to `solveMovingBaseline`. The ambiguity set is shared. */
+export interface MovingBaselineConfig {
+  epochs: MovingBaselineEpoch[];
+  ambiguityIds: string[];
+  ambiguitySatellites: Record<string, string>;
+  wavelengthsM: Record<string, number>;
+  offsetsM: Record<string, number>;
+  floatOnlySystems?: string[];
+  model: RtkMeasurementModel;
+  floatOptions?: RtkFloatOptions;
+  fixedOptions?: RtkFixedOptions;
+  initialBaselineM?: [number, number, number];
+  /** Carry each solved baseline into the next epoch. Defaults to true. */
+  warmStart?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Time of closest approach (TCA)
+// ---------------------------------------------------------------------------
+
+/** Finder sampling controls (defaults: 60 s coarse step, 1e-3 s tolerance). */
+export interface TcaFinderOptions {
+  coarseStepSeconds?: number;
+  timeToleranceSeconds?: number;
+}
+
+/** Collision-probability options for the TCA conjunction finders. */
+export interface TcaPcOptions {
+  hardBodyRadiusKm: number;
+  /** Pc method; defaults to "foster_equal_area". */
+  method?: "foster_equal_area" | "foster_numerical" | "alfano_2005";
+  /** Primary-object 3x3 position covariance (flat row-major, km^2). */
+  primaryCovarianceKm2?: number[];
+  /** Secondary-object 3x3 position covariance (flat row-major, km^2). */
+  secondaryCovarianceKm2?: number[];
+}
+
+/** A borrowed TLE line pair for the screening catalogs. */
+export interface Tle {
+  line1: string;
+  line2: string;
+}
+
+/** One local time-of-closest-approach candidate. */
+export interface TcaCandidate {
+  /** Refined TCA split Julian date (whole boundary). */
+  tcaJdWhole: number;
+  tcaJdFraction: number;
+  /** Recombined TCA Julian date. */
+  tcaJd: number;
+  tcaSecondsSinceWindowStart: number;
+  missDistanceKm: number;
+  /** Primary minus secondary TEME position [x, y, z], km. */
+  relativePositionKm: [number, number, number];
+  /** Primary minus secondary TEME velocity [vx, vy, vz], km/s. */
+  relativeVelocityKmS: [number, number, number];
+}
+
+/** A TCA candidate with the collision probability evaluated at that TCA. */
+export interface TcaConjunction {
+  candidate: TcaCandidate;
+  pc: number;
+  missKm: number;
+  relativeSpeedKmS: number;
+  sigmaXKm: number;
+  sigmaZKm: number;
+}
+
+/** One threshold-screening hit. */
+export interface TcaScreeningHit {
+  /** Index of the secondary in the supplied catalog. */
+  secondaryIndex: number;
+  candidate: TcaCandidate;
+}
+
+/** A threshold-screening hit with Pc evaluated at the returned TCA. */
+export interface TcaScreeningConjunctionHit {
+  secondaryIndex: number;
+  conjunction: TcaConjunction;
+}
+
+// ---------------------------------------------------------------------------
+// NeQuick-G full three-dimensional slant ionosphere
+// ---------------------------------------------------------------------------
+//
+// `nequickGStecTecu(eval)` / `nequickGDelayM(eval, frequencyHz)` take a serde-
+// `any` object. Import:
+//
+//   import { nequickGStecTecu } from "@neilberkman/sidereon";
+//   import type { NequickGEval } from "@neilberkman/sidereon/types";
+
+/** One receiver-to-satellite ray (geometry, epoch, and the Galileo broadcast
+ * effective-ionisation coefficients) for the full NeQuick-G slant model. */
+export interface NequickGEval {
+  /** Galileo broadcast effective-ionisation coefficient a_i0. */
+  ai0: number;
+  ai1: number;
+  ai2: number;
+  /** Month of the year, 1..=12. */
+  month: number;
+  /** UTC time of day in hours, [0, 24]. */
+  utcHours: number;
+  /** Receiver geodetic longitude, degrees. */
+  stationLonDeg: number;
+  /** Receiver geodetic latitude, degrees. */
+  stationLatDeg: number;
+  /** Receiver height above the reference sphere, metres. */
+  stationHeightM: number;
+  /** Satellite geodetic longitude, degrees. */
+  satelliteLonDeg: number;
+  /** Satellite geodetic latitude, degrees. */
+  satelliteLatDeg: number;
+  /** Satellite height above the reference sphere, metres. */
+  satelliteHeightM: number;
+}
+
+// ---------------------------------------------------------------------------
+// Range RAIM / fault detection and exclusion (design-matrix form)
+// ---------------------------------------------------------------------------
+//
+// `raimFdeDesign(rows, options?)` takes a serde-`any` array and object and
+// returns the result as a plain object (typed `any` by wasm-bindgen). Import:
+//
+//   import { raimFdeDesign } from "@neilberkman/sidereon";
+//   import type { RaimFdeRow, RaimFdeResult } from "@neilberkman/sidereon/types";
+
+/** One linearized range measurement. */
+export interface RaimFdeRow {
+  /** Stable measurement identifier, e.g. a satellite token "G01". */
+  id: string;
+  /** Observed-minus-computed range residual, metres. */
+  residualM: number;
+  /** Design-matrix row (partials of predicted range w.r.t. each state
+   * parameter). Length equals the estimated state dimension. */
+  designRow: number[];
+  /** Inverse-variance weight 1 / sigma^2; finite and strictly positive. */
+  weight: number;
+}
+
+/** Options for `raimFdeDesign`. Every field is optional. */
+export interface RaimFdeOptions {
+  /** False-alarm probability for the global chi-square test. Default 1.0e-3. */
+  pFa?: number;
+  /** Maximum measurements the exclusion loop may remove. Default unbounded. */
+  maxExclusions?: number;
+  /** Minimum redundancy an exclusion must leave behind. Default 1. */
+  minRedundancy?: number;
+}
+
+/** Global chi-square consistency test over the protected set. */
+export interface RaimChiSquareTest {
+  weightedSumSquares: number;
+  /** Redundancy: nUsed - nState. */
+  dof: number;
+  /** Chi-square threshold, absent when dof <= 0. */
+  threshold?: number;
+  testable: boolean;
+  faultDetected: boolean;
+}
+
+/** Per-measurement diagnostic, in input order. */
+export interface RaimMeasurementDiagnostic {
+  id: string;
+  excluded: boolean;
+  postFitResidualM: number;
+  normalizedResidual: number;
+}
+
+/** Result of `raimFdeDesign`. */
+export interface RaimFdeResult {
+  /** Protected weighted-least-squares state correction, length nState. */
+  stateCorrection: number[];
+  /** Protected state covariance (H^T W H)^-1, nState-by-nState. */
+  stateCovariance: number[][];
+  globalTest: RaimChiSquareTest;
+  /** Excluded measurement ids, in exclusion order. */
+  excluded: string[];
+  diagnostics: RaimMeasurementDiagnostic[];
+  iterations: number;
+}
+
+// ---------------------------------------------------------------------------
+// PPP auto-init (SPP-seeded) drivers
+// ---------------------------------------------------------------------------
+//
+// `solvePppAutoInitFloat(sp3, epochs, options?, config)` and
+// `solvePppAutoInitFixed(sp3, epochs, options?, floatConfig, fixedConfig)` seed
+// the float state from the SPP solver, so no initial state is supplied. Import:
+//
+//   import { solvePppAutoInitFloat } from "@neilberkman/sidereon";
+//   import type { PppAutoInitOptions } from "@neilberkman/sidereon/types";
+
+/** Explicit static-position/clock seed that bypasses the SPP auto-init stages. */
+export interface PppInitialGuess {
+  positionM: [number, number, number];
+  /** Receiver clock seed, metres (duplicated across every epoch). */
+  clockM: number;
+}
+
+/** SPP surface meteorology for the auto-init seed troposphere. */
+export interface PppSppSurfaceMet {
+  pressureHpa: number;
+  temperatureK: number;
+  relativeHumidity: number;
+}
+
+/** Auto-initialization policy for the raw-epochs PPP drivers. Every field is
+ * optional; omitting `initialGuess` runs the per-epoch SPP seed. */
+export interface PppAutoInitOptions {
+  /** Explicit seed; present skips the SPP/mean stages entirely. */
+  initialGuess?: PppInitialGuess;
+  /** SPP cold-start guess [x, y, z, b] for each per-epoch seed. Default zeros. */
+  sppInitialGuess?: [number, number, number, number];
+  /** Apply the troposphere correction in the SPP seed. Default false. */
+  sppTroposphere?: boolean;
+  /** Surface meteorology used by the SPP seed troposphere. */
+  sppMet?: PppSppSurfaceMet;
+}
+
+// ---------------------------------------------------------------------------
+// Sequential RTK baseline arc driver
+// ---------------------------------------------------------------------------
+//
+// `solveRtkArc(epochs, config)` takes serde-`any` arrays/objects and returns
+// the solution as a plain object (typed `any` by wasm-bindgen). Import:
+//
+//   import { solveRtkArc } from "@neilberkman/sidereon";
+//   import type { RtkArcEpoch, RtkArcConfig, RtkArcSolution } from "@neilberkman/sidereon/types";
+
+/** One raw single-frequency code/carrier observation at a receiver. */
+export interface RtkArcObservation {
+  satelliteId: string;
+  /** Ambiguity-arc id (the satellite id for a clean arc; a distinct id splits
+   * a cycle-slip arc so the single-difference key resets). */
+  ambiguityId: string;
+  codeM: number;
+  phaseM: number;
+  /** Loss-of-lock indicator. Bit 0 set marks a cycle-slip event when enabled. */
+  lli?: number;
+}
+
+/** One raw RTK arc epoch: paired base/rover observations and satellite positions. */
+export interface RtkArcEpoch {
+  base: RtkArcObservation[];
+  rover: RtkArcObservation[];
+  /** Shared receive-time satellite ECEF positions (metres), satellite -> xyz. */
+  satellitePositionsM: Record<string, [number, number, number]>;
+  /** Transmit-time positions for the base; defaults to the shared map. */
+  baseSatellitePositionsM?: Record<string, [number, number, number]>;
+  /** Transmit-time positions for the rover; defaults to the shared map. */
+  roverSatellitePositionsM?: Record<string, [number, number, number]>;
+  velocityMps?: [number, number, number];
+  /** Epoch time coordinate (seconds) for the prediction-delta computation. */
+  predictionTimeS?: number;
+}
+
+/** Reference-satellite selection policy for the arc. */
+export interface RtkArcReferenceSelection {
+  /** "auto" (default), "satellite", or "perSystem". */
+  mode?: "auto" | "satellite" | "perSystem";
+  /** Fixed reference satellite token (mode "satellite", single-system only). */
+  satellite?: string;
+  /** Constellation letter -> reference satellite (mode "perSystem"). */
+  references?: Record<string, string>;
+}
+
+/** Optional predicted-residual screen for one epoch update. */
+export interface RtkArcInnovationScreen {
+  thresholdSigma: number;
+  minRows: number;
+}
+
+/** Per-epoch sequential-update controls. Every field is optional. */
+export interface RtkArcUpdateOptions {
+  holdSigmaM?: number;
+  positionTolM?: number;
+  ambiguityTolM?: number;
+  maxIterations?: number;
+  /** Kinematic baseline process-noise sigma (metres); 0 is the static filter. */
+  processNoiseBaselineSigmaM?: number;
+  /** Prediction dynamics. Default "constantPosition". */
+  dynamicsModel?: "constantPosition" | "velocityPropagated";
+  /** Constellation letters kept float-only (never integer-fixed), e.g. ["R"]. */
+  floatOnlySystems?: string[];
+  innovationScreen?: RtkArcInnovationScreen;
+  /** Emit per-epoch residual diagnostics. Default false. */
+  reportResiduals?: boolean;
+  /** AR commitment arming gate (metres); omit to keep always-armed. */
+  arArmingSigmaM?: number;
+  /** LAMBDA acceptance ratio threshold. Default 3.0. */
+  ratioThreshold?: number;
+}
+
+/** Cycle-slip handling policy for arc preprocessing. */
+export type RtkArcCycleSlipPolicy = "error" | "dropSatellite" | "splitArc";
+
+/** Optional preprocessing chained ahead of the RTK arc solve. */
+export interface RtkArcPreprocessing {
+  /** Reads `RtkArcObservation.lli`; omit to skip cycle-slip preprocessing. */
+  cycleSlip?: RtkArcCycleSlipPolicy;
+  /** Hatch code-smoothing window cap; omit to skip smoothing. */
+  hatchWindowCap?: number;
+  /** Base-receiver elevation mask in degrees; omit to skip masking. */
+  elevationMaskDeg?: number;
+}
+
+/** The config object passed to `solveRtkArc`. */
+export interface RtkArcConfig {
+  /** Base-station ECEF position [x, y, z], metres. */
+  baseM: [number, number, number];
+  reference?: RtkArcReferenceSelection;
+  model: RtkMeasurementModel;
+  /** Baseline prior sigma (metres) for the initial information matrix. */
+  baselinePriorSigmaM: number;
+  /** Ambiguity prior sigma (metres) for each new single-difference column. */
+  ambiguityPriorSigmaM: number;
+  initialBaselineM?: [number, number, number];
+  /** Per-ambiguity carrier wavelengths (metres) for the integer search. */
+  wavelengthsM?: Record<string, number>;
+  /** Per-ambiguity code-to-phase metre offsets for the integer search. */
+  offsetsM?: Record<string, number>;
+  updateOpts?: RtkArcUpdateOptions;
+  preprocessing?: RtkArcPreprocessing;
+}
+
+/** Option groups used by the validated fixed solve inside `solveStaticRtkArc`. */
+export interface RtkValidatedFixedOptions {
+  float?: RtkFloatOptions;
+  fixed?: RtkFixedOptions;
+  residual?: RtkResidualValidationOptions;
+}
+
+/** The config object passed to `solveStaticRtkArc`. */
+export interface RtkStaticArcConfig {
+  arc: RtkArcConfig;
+  opts?: RtkValidatedFixedOptions;
+}
+
+/** Scalar summary of one epoch's LAMBDA integer search. */
+export interface RtkArcSearchSummary {
+  integerStatus: "Fixed" | "NotFixed";
+  integerMethod: string;
+  integerRatio?: number;
+  integerBestScore?: number;
+  integerSecondBestScore?: number;
+  integerCandidates: number;
+  partialEnabled: boolean;
+  partialFixed: boolean;
+}
+
+/** One public residual row at a reported epoch solution. */
+export interface RtkArcResidual {
+  epochIndex: number;
+  satelliteId: string;
+  referenceSatelliteId: string;
+  ambiguityId: string;
+  codeM: number;
+  phaseM: number;
+  codeSigmaM: number;
+  phaseSigmaM: number;
+  codeNormalized: number;
+  phaseNormalized: number;
+}
+
+/** Static float RTK solution returned inside `RtkStaticArcSolution`. */
+export interface RtkStaticArcFloatSolution {
+  baselineM: [number, number, number];
+  ambiguitiesM: Record<string, number>;
+  ambiguityCovarianceM: number[];
+  ambiguityCovarianceInverseM: number[];
+  residuals: RtkArcResidual[];
+  iterations: number;
+  converged: boolean;
+  status: "StateTolerance" | "MaxIterations";
+  codeRmsM: number;
+  phaseRmsM: number;
+  weightedRmsM: number;
+  nObservations: number;
+}
+
+/** Static fixed RTK solution returned inside `RtkStaticArcSolution`. */
+export interface RtkStaticArcFixedSolution {
+  baselineM: [number, number, number];
+  freeAmbiguitiesM: Record<string, number>;
+  fixedAmbiguitiesCycles: Record<string, number>;
+  fixedAmbiguitiesM: Record<string, number>;
+  residuals: RtkArcResidual[];
+  search: RtkArcSearchSummary;
+  iterations: number;
+  converged: boolean;
+  status: "StateTolerance" | "MaxIterations";
+  codeRmsM: number;
+  phaseRmsM: number;
+  weightedRmsM: number;
+  nObservations: number;
+}
+
+/** One residual-validation outlier selected by fixed RTK validation. */
+export interface RtkResidualValidationOutlier {
+  epochIndex: number;
+  satelliteId: string;
+  referenceSatelliteId: string;
+  ambiguityId: string;
+  kind: "code" | "phase";
+  residualM: number;
+  sigmaM: number;
+  normalizedResidual: number;
+  thresholdSigma: number;
+}
+
+/** Residual-validation metadata for the accepted fixed RTK solution. */
+export interface RtkResidualValidationResult {
+  thresholdSigma: number;
+  maxExclusions: number;
+  excludedSats: string[];
+  exclusions: RtkResidualValidationOutlier[];
+}
+
+/** Validated fixed RTK solution returned inside `RtkStaticArcSolution`. */
+export interface RtkValidatedFixedSolution {
+  floatSolution: RtkStaticArcFloatSolution;
+  fixedSolution: RtkStaticArcFixedSolution;
+  residualValidation?: RtkResidualValidationResult;
+  ambiguityIds: string[];
+  ambiguitySatellites: Record<string, string>;
+}
+
+/** The full static RTK arc solution returned by `solveStaticRtkArc`. */
+export interface RtkStaticArcSolution {
+  references: Record<string, string>;
+  ambiguityIds: string[];
+  ambiguitySatellites: Record<string, string>;
+  floatSolution: RtkStaticArcFloatSolution;
+  fixedSolution: RtkValidatedFixedSolution;
+  droppedSats: string[];
+  splitCycleSlipArcs: RtkArcCycleSlipSplitArc[];
+  elevationMaskedSats: string[];
+}
+
+/** One epoch's predicted-residual (innovation) screen outcome, present only when
+ * the screen was enabled via `updateOpts.innovationScreen`. */
+export interface RtkArcInnovationScreenResult {
+  thresholdSigma: number;
+  minRows: number;
+  inputRows: number;
+  acceptedRows: number;
+  rejectedRows: number;
+  rejectedCodeRows: number;
+  rejectedPhaseRows: number;
+  maxAbsNormalizedInnovation?: number;
+  maxRejectedAbsNormalizedInnovation?: number;
+  /** Whether the epoch was coasted (too few rows survived the screen). */
+  coasted: boolean;
+}
+
+/** One epoch's reported baseline/ambiguity solution. */
+export interface RtkArcEpochSolution {
+  reportedBaselineM: [number, number, number];
+  floatBaselineM: [number, number, number];
+  integerFixed: boolean;
+  integerRatio: number;
+  newlyFixed: string[];
+  fixedIds: string[];
+  /** Reported single-difference ambiguities (id -> metres). */
+  sdAmbiguitiesM: Record<string, number>;
+  fixedDoubleDifferenceIds: string[];
+  usedSatelliteIds: string[];
+  search?: RtkArcSearchSummary;
+  residuals: RtkArcResidual[];
+  /** Per-epoch innovation-screen result, present only when the screen is enabled
+   * for the arc via `updateOpts.innovationScreen`. */
+  innovationScreen?: RtkArcInnovationScreenResult;
+}
+
+/** The final carried filter state (the serializable streaming ABI). */
+export interface RtkArcFilterState {
+  version: number;
+  references: Record<string, string>;
+  sdAmbiguityIds: string[];
+  baselineM: [number, number, number];
+  sdAmbiguitiesM: number[];
+  /** Row-major n-by-n information matrix, n = 3 + sdAmbiguityIds.length. */
+  information: number[];
+  ambiguityPriorSigmaM: number;
+  epochCount: number;
+  fixedCycles: Record<string, number>;
+  fixedM: Record<string, number>;
+}
+
+/** Cycle-slip split-arc metadata emitted by preprocessing. */
+export interface RtkArcCycleSlipSplitArc {
+  receiver: "base" | "rover";
+  satelliteId: string;
+  ambiguityId: string;
+  startEpochIndex: number;
+  endEpochIndex: number;
+  nEpochs: number;
+}
+
+/** The full sequential RTK arc solution returned by `solveRtkArc`. */
+export interface RtkArcSolution {
+  /** Per-constellation reference single-difference ambiguity ids. */
+  references: Record<string, string>;
+  epochs: RtkArcEpochSolution[];
+  finalState: RtkArcFilterState;
+  droppedSats: string[];
+  splitCycleSlipArcs: RtkArcCycleSlipSplitArc[];
+  elevationMaskedSats: string[];
+  /** Row-major posterior covariance, n-by-n with n = finalState information size. */
+  measurementCovariance: number[];
+}
+
+/** One receiver's dual-frequency code/carrier observation. */
+export interface RtkDualFrequencyObservation {
+  ambiguityId: string;
+  p1M: number;
+  p2M: number;
+  phi1Cycles: number;
+  phi2Cycles: number;
+  f1Hz: number;
+  f2Hz: number;
+  lli1?: number;
+  lli2?: number;
+}
+
+/** Paired base/rover dual-frequency observation for one satellite. */
+export interface RtkDualFrequencySatelliteObservation {
+  satelliteId: string;
+  base: RtkDualFrequencyObservation;
+  rover: RtkDualFrequencyObservation;
+}
+
+/** One dual-frequency RTK arc epoch. */
+export interface RtkDualFrequencyArcEpoch {
+  jdWhole: number;
+  jdFraction: number;
+  epochSortKey?: string;
+  gapTimeS?: number;
+  observations: RtkDualFrequencySatelliteObservation[];
+  satellitePositionsM: Record<string, [number, number, number]>;
+  baseSatellitePositionsM?: Record<string, [number, number, number]>;
+  roverSatellitePositionsM?: Record<string, [number, number, number]>;
+  velocityMps?: [number, number, number];
+  predictionTimeS?: number;
+}
+
+/** Dual-frequency cycle-slip classifier thresholds. */
+export interface RtkDualCycleSlipOptions {
+  gfThresholdM?: number;
+  mwThresholdCycles?: number;
+  minArcGapS?: number;
+}
+
+/** Optional dual-frequency cycle-slip preprocessing for wide-lane fixing. */
+export interface RtkDualCycleSlipConfig {
+  policy: RtkArcCycleSlipPolicy;
+  options?: RtkDualCycleSlipOptions;
+}
+
+/** Wide-lane integer estimation controls. */
+export interface RtkWideLaneOptions {
+  minEpochs: number;
+  toleranceCycles: number;
+  skipShortFragments: boolean;
+}
+
+/** The config object passed to `fixWideLaneRtkArc`. */
+export interface RtkWideLaneArcConfig {
+  baseM: [number, number, number];
+  reference?: RtkArcReferenceSelection;
+  options: RtkWideLaneOptions;
+  cycleSlip?: RtkDualCycleSlipConfig;
+}
+
+/** The wide-lane RTK arc solution returned by `fixWideLaneRtkArc`. */
+export interface RtkWideLaneArcSolution {
+  references: Record<string, string>;
+  wideLaneCycles: Record<string, number>;
+  epochs: RtkDualFrequencyArcEpoch[];
+  droppedSats: string[];
+  splitCycleSlipArcs: RtkArcCycleSlipSplitArc[];
+}
+
+/** The config object passed to `prepareIonosphereFreeRtkArc`. */
+export interface RtkIonosphereFreeArcConfig {
+  baseM: [number, number, number];
+  initialBaselineM?: [number, number, number];
+  reference?: RtkArcReferenceSelection;
+  applyTroposphere?: boolean;
+}
+
+/** The ionosphere-free RTK arc setup returned by `prepareIonosphereFreeRtkArc`. */
+export interface RtkIonosphereFreeArcSolution {
+  references: Record<string, string>;
+  epochs: RtkArcEpoch[];
+  wavelengthsM: Record<string, number>;
+  offsetsM: Record<string, number>;
+}
+
+// ---------------------------------------------------------------------------
+// RTCM construction + encode (the inverse of decodeRtcm)
+// ---------------------------------------------------------------------------
+//
+// `encodeRtcm(message)` / `encodeRtcmFrame(message)` take a `type`-tagged plain
+// object carrying the raw transmitted field integers and return the encoded body
+// / framed bytes. The accepted shapes mirror the `decodeRtcm` output minus the
+// derived convenience fields. Import:
+//
+//   import { encodeRtcmFrame } from "@neilberkman/sidereon";
+//   import type { RtcmMessageInput } from "@neilberkman/sidereon/types";
+
+/** A 1005 / 1006 station antenna reference point for encoding. */
+export type RtcmStationCoordinatesInput = Omit<
+  RtcmStationCoordinates,
+  "xM" | "yM" | "zM" | "antennaHeightM"
+>;
+
+/** A 1007 / 1008 / 1033 antenna or receiver descriptor for encoding. */
+export type RtcmAntennaDescriptorInput = RtcmAntennaDescriptor;
+
+/** An MSM4 / MSM7 observation message for encoding. */
+export type RtcmMsmInput = RtcmMsm;
+
+/** A 1019 GPS broadcast ephemeris for encoding (`messageNumber` is implied). */
+export type RtcmGpsEphemerisInput = Omit<RtcmGpsEphemeris, "messageNumber">;
+
+/** A 1020 GLONASS broadcast ephemeris for encoding (`messageNumber` is implied). */
+export type RtcmGlonassEphemerisInput = Omit<RtcmGlonassEphemeris, "messageNumber">;
+
+/** A recognized-but-undecoded message for encoding (body preserved verbatim). */
+export type RtcmUnsupportedInput = RtcmUnsupported;
+
+/** The message IR accepted by `encodeRtcm` / `encodeRtcmFrame`, tagged by `type`.
+ * A `decodeRtcm` output object is also accepted (its extra derived fields are
+ * ignored). */
+export type RtcmMessageInput =
+  | RtcmMsmInput
+  | RtcmStationCoordinatesInput
+  | RtcmAntennaDescriptorInput
+  | RtcmGpsEphemerisInput
+  | RtcmGlonassEphemerisInput
+  | RtcmUnsupportedInput;