@neilberkman/sidereon 0.9.0 → 0.9.2

package/pkg-node/sidereon.d.ts

@@ -1367,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.
@@ -2193,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`].
  */
@@ -2421,6 +2541,49 @@ export class MappingFactors {
     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.
  */
@@ -3500,6 +3663,61 @@ export class PppFloatSolution {
     readonly ztdResidualM: number | undefined;
 }
 
+/**
+ * A precise-ephemeris source built from samples rather than parsed SP3 text.
+ *
+ * Implements the same `ObservableEphemerisSource` contract as a parsed [`Sp3`]
+ * product and shares its interpolation substrate, so [`predictRanges`] accepts
+ * either handle. Build one with [`preciseEphemerisSamplesFromSamples`].
+ */
+export class PreciseEphemerisSampleSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Predict geometric ranges for many requests in one call. See the shared
+     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
+     * this is the sample-source entry point.
+     */
+    predictRanges(requests: any, options: any): any;
+    /**
+     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
+     */
+    readonly satellites: string[];
+}
+
+/**
+ * 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`.
@@ -4129,6 +4347,16 @@ export class Sp3 {
      * coverage gap (the engine refuses to extrapolate).
      */
     interpolate(satellite: string, j2000_seconds: Float64Array): Sp3Interpolation;
+    /**
+     * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
+     * against this ephemeris in one call. `requests` is an array of
+     * `{ sat, receiverEcefM, tRxJ2000S }`; returns an array of
+     * `{ geometricRangeM, satClockS, transmitTimeJ2000S, satPosEcefM }`
+     * index-aligned to `requests`. The same call shape works on a
+     * `PreciseEphemerisSampleSource`. Delegates to the serial reference kernel
+     * `sidereon_core::observables::predict_ranges`.
+     */
+    predictRanges(requests: any, options: any): any;
     /**
      * Run single-point positioning against this ephemeris.
      *
@@ -5119,6 +5347,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.
@@ -5221,6 +5464,19 @@ 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.
  *
@@ -5267,6 +5523,33 @@ 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.
  */
@@ -5328,6 +5611,39 @@ 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.
  *
@@ -5601,6 +5917,24 @@ export function gnssVisibilitySeries(sp3: Sp3, station_ecef_m: Float64Array, sta
  */
 export function gnssVisible(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: number, options: any): GnssVisibleSatellite[];
 
+/**
+ * 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 gpsUtcOffsetS(year: number, month: number, day: number): number;
+
+/**
+ * Trace of the Gauss-Newton Hessian approximation `J^T J`: the sum of the
+ * squared column norms of the Jacobian, with no inverse formed.
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array`. Delegates to
+ * `sidereon_core::astro::math::least_squares::hessian_trace`.
+ */
+export function hessianTrace(jacobian: Float64Array, m: number, n: number): number;
+
 /**
  * Gauss angles-only orbit determination.
  *
@@ -5670,6 +6004,17 @@ export function itrsToGcrs(position_km: Float64Array, epochs_unix_us: BigInt64Ar
  */
 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).
@@ -5686,6 +6031,17 @@ export function j2000SecondsToCivil(seconds: bigint): CivilDateTime;
  */
 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).
  *
@@ -5729,6 +6085,31 @@ 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.
  *
@@ -5854,11 +6235,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.
  */
@@ -5901,6 +6318,21 @@ export function nequickGStecTecu(_eval: any): number;
  */
 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`.
@@ -6084,6 +6516,40 @@ export function phaseMeters(phi_cycles: number, f_hz: number): number;
  */
 export function pppCorrections(sp3: Sp3, epochs: any, receiver_ecef_m: Float64Array, options: any): any;
 
+/**
+ * Build a sample-backed precise-ephemeris source from an array of samples.
+ *
+ * `samples` is an array of `{ sat, epoch, positionEcefM, clockS?, clockEvent? }`
+ * objects (see the sample field docs). Samples are grouped by satellite in their
+ * supplied order; each satellite needs at least two strictly time-increasing
+ * samples. Throws a `TypeError` for a malformed object or bad satellite token
+ * and a `RangeError` for a non-finite epoch or a source validation failure
+ * (empty input, a single-sample satellite, non-monotonic epochs, a non-finite
+ * sample). Delegates to `sidereon_core::sp3::PreciseEphemerisSamples::from_samples`.
+ */
+export function preciseEphemerisSamplesFromSamples(samples: any): PreciseEphemerisSampleSource;
+
+/**
+ * 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.
@@ -6264,12 +6730,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.
  */
@@ -6432,6 +6918,20 @@ export function solveVelocityBroadcast(broadcast: BroadcastEphemeris, observatio
  */
 export function solveWithFallback(precise: Sp3[], broadcast: BroadcastEphemeris, request: any, policy: any): SourcedSolution;
 
+/**
+ * Extract a parsed SP3 product as the canonical precise-ephemeris samples, one
+ * per real position record in ascending epoch order.
+ *
+ * Returns an array of `{ sat, epoch, positionEcefM, clockS, clockEvent }`
+ * objects. Round-tripping the result back through
+ * [`preciseEphemerisSamplesFromSamples`] rebuilds an interpolatable source that
+ * reproduces the SP3-parsed source's interpolated states and predicted ranges
+ * to the documented round-trip precision (byte-identical for samples whose
+ * meters are the faithful image of the fit nodes; see the core module docs).
+ * Delegates to `sidereon_core::sp3::Sp3::precise_ephemeris_samples`.
+ */
+export function sp3PreciseEphemerisSamples(sp3: Sp3): any;
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  */
@@ -6464,6 +6964,16 @@ export function subSolarPoint(sun_ecef: Float64Array): any;
  */
 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.
  */
@@ -6481,6 +6991,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.
  *
@@ -6523,8 +7042,8 @@ export function timescaleOffsetAtS(from: TimeScale, to: TimeScale, utc_jd: numbe
  *
  * 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
+ * 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;