@neilberkman/sidereon 0.16.1 → 0.17.0

package/pkg-node/sidereon.d.ts

@@ -1687,6 +1687,76 @@ export class EllipsoidalHeightM {
     readonly valueM: number;
 }
 
+/**
+ * Contiguous state and media-correction arrays from one emission batch.
+ */
+export class EmissionMediaBatch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Error message for row `index`, or `undefined` when the row has no error.
+     */
+    error(index: number): string | undefined;
+    /**
+     * Satellite clock offsets in seconds, with `NaN` for unavailable rows.
+     */
+    readonly clockS: Float64Array;
+    /**
+     * Number of satellite rows in the batch.
+     */
+    readonly count: number;
+    /**
+     * Per-row success and error messages as `{ ok, error }[]`.
+     */
+    readonly elementResults: any;
+    /**
+     * Ionospheric slant group delays in metres, with `NaN` for unavailable rows.
+     */
+    readonly ionosphereSlantDelayM: Float64Array;
+    /**
+     * Satellite ECEF positions as flat `[x0, y0, z0, ...]`, metres.
+     *
+     * Rows without a usable position are filled with `NaN`; check `statuses`
+     * before consuming the corresponding row.
+     */
+    readonly positionEcefM: Float64Array;
+    /**
+     * Per-row status labels, index-aligned with the numeric arrays.
+     */
+    readonly statusLabels: string[];
+    /**
+     * Per-row typed status values, index-aligned with the numeric arrays.
+     */
+    readonly statuses: any[];
+    /**
+     * Tropospheric slant delays in metres, with `NaN` for unavailable rows.
+     */
+    readonly troposphereDelayM: Float64Array;
+}
+
+/**
+ * Per-satellite status for an emission media batch row.
+ */
+export enum EmissionMediaStatus {
+    /**
+     * State, clock, and requested media corrections were produced.
+     */
+    Valid = 0,
+    /**
+     * The ephemeris product has no usable state for this satellite and epoch.
+     */
+    Gap = 1,
+    /**
+     * A state was available, but elevation was below the requested cutoff.
+     */
+    BelowElevationCutoff = 2,
+    /**
+     * A non-gap scalar evaluation error occurred.
+     */
+    Error = 3,
+}
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -1969,6 +2039,111 @@ export enum GeodesicError {
     InvalidInput = 0,
 }
 
+/**
+ * A geodesic polygon fence on WGS84.
+ */
+export class Geofence {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Containment probability for one position and uncertainty object.
+     *
+     * `uncertainty.kind` is one of `"enuCovarianceM2"`, `"ecefCovarianceM2"`,
+     * `"cepRadiusM"`, or `"horizontalRadius"`. `options.method` is
+     * `"boundaryNormal"` or `"planarQuadrature"`.
+     */
+    containmentProbability(lat_rad: number, lon_rad: number, height_m: number, uncertainty_value: any, options: any): number;
+    /**
+     * Boolean containment for one WGS84 geodetic position.
+     */
+    contains(lat_rad: number, lon_rad: number, height_m: number): boolean;
+    /**
+     * Probabilistic crossing detection over geodetic position estimates.
+     *
+     * `samples` is an array of `{ latRad, lonRad, heightM?, uncertainty }`.
+     * `options.enterConfidence` and `options.leaveConfidence` configure
+     * hysteresis; absent values use the core defaults.
+     */
+    crossingProbability(samples: any, options: any): any;
+    /**
+     * Signed distance to the fence boundary in metres.
+     */
+    distanceToBoundary(lat_rad: number, lon_rad: number, height_m: number): number;
+    /**
+     * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+     *
+     * `vertices` is `[latRad, lonRad, ...]`. Use `geofenceFromVertices3d`
+     * for `[latRad, lonRad, heightM, ...]` rows.
+     */
+    constructor(vertices: Float64Array);
+    /**
+     * Whether the core small-region planar path can evaluate this position.
+     */
+    planarFastPathApplies(lat_rad: number, lon_rad: number, height_m: number): boolean;
+    /**
+     * Number of polygon edges.
+     */
+    readonly edgeCount: number;
+    /**
+     * Fence vertices in open-polygon form as flat `[latRad, lonRad, heightM]` rows.
+     */
+    readonly vertices: Float64Array;
+}
+
+/**
+ * Geofence crossing event direction.
+ */
+export enum GeofenceCrossingKind {
+    /**
+     * The sample sequence entered the fence.
+     */
+    Entered = 0,
+    /**
+     * The sample sequence left the fence.
+     */
+    Left = 1,
+}
+
+/**
+ * Geofence construction and evaluation error variants.
+ */
+export enum GeofenceError {
+    /**
+     * Fewer than three distinct vertices were supplied.
+     */
+    TooFewVertices = 0,
+    /**
+     * A geofence input value was outside its domain.
+     */
+    InvalidInput = 1,
+    /**
+     * The geodesic direct or inverse calculation failed.
+     */
+    Geodesic = 2,
+    /**
+     * ECEF covariance rotation failed.
+     */
+    Dop = 3,
+    /**
+     * Covariance or radius validation failed.
+     */
+    ErrorMetrics = 4,
+}
+
+/**
+ * Probability integration method for geofence uncertainty.
+ */
+export enum GeofenceProbabilityMethod {
+    /**
+     * Gaussian half-space approximation from boundary distance and normal variance.
+     */
+    BoundaryNormal = 0,
+    /**
+     * Fixed quadrature over the local planarized fence.
+     */
+    PlanarQuadrature = 1,
+}
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -4760,6 +4935,73 @@ export class PreciseEphemerisSampleSource {
     readonly satellites: string[];
 }
 
+/**
+ * Evaluable precise-interpolant artifact opened from canonical store bytes.
+ */
+export class PreciseInterpolantArtifact {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate one satellite state at a J2000-second epoch.
+     */
+    evaluate(satellite: string, j2000_seconds: number): Sp3State;
+    /**
+     * Number of bytes retained by this artifact handle.
+     */
+    readonly byteLength: number;
+    /**
+     * File-level artifact checksum.
+     */
+    readonly checksum64: bigint;
+    /**
+     * Satellite tokens present in the artifact, ascending.
+     */
+    readonly satellites: string[];
+    /**
+     * Artifact time scale label from the stored epoch axis.
+     */
+    readonly timeScale: string;
+}
+
+/**
+ * Error category for precise-interpolant artifact open or serialization.
+ */
+export enum PreciseInterpolantArtifactError {
+    /**
+     * File I/O failed in the core artifact API.
+     */
+    Io = 0,
+    /**
+     * Artifact bytes could not be parsed.
+     */
+    Parse = 1,
+    /**
+     * The artifact version tag is unsupported.
+     */
+    UnsupportedVersion = 2,
+    /**
+     * The artifact time-scale tag is unsupported.
+     */
+    UnsupportedTimeScale = 3,
+    /**
+     * A satellite-system tag is unsupported.
+     */
+    UnsupportedSatelliteSystem = 4,
+    /**
+     * A satellite appears more than once in the artifact index.
+     */
+    DuplicateSatellite = 5,
+    /**
+     * The artifact file-level checksum did not match.
+     */
+    Checksum = 6,
+    /**
+     * A satellite payload checksum did not match its index record.
+     */
+    SatelliteChecksum = 7,
+}
+
 /**
  * The per-request results of a batch observable prediction, index-aligned to
  * the input requests. Each request independently either produced observables or
@@ -5721,6 +5963,21 @@ export class Sp3 {
      * TypeScript type. Returns the corrected solution and the base baseline.
      */
     dgnssSolve(request: any): DgnssSolution;
+    /**
+     * Evaluate emission-time state and media corrections for index-aligned satellites.
+     *
+     * `satellites` and `emissionEpochsJ2000S` share a row count. `receiverEcefM`
+     * is `[x, y, z]` metres. Without an IONEX product this can still request
+     * troposphere corrections by passing `{ troposphere: true }`.
+     */
+    emissionMediaBatch(satellites: string[], emission_epochs_j2000_s: Float64Array, receiver_ecef_m: Float64Array, options: any): EmissionMediaBatch;
+    /**
+     * Evaluate emission-time state plus IONEX/troposphere media corrections.
+     *
+     * `options.ionosphere` defaults to `true` on this IONEX-bearing path.
+     * `options.troposphere` defaults to `false`.
+     */
+    emissionMediaBatchIonex(ionex: Ionex, satellites: string[], emission_epochs_j2000_s: Float64Array, receiver_ecef_m: Float64Array, options: any): EmissionMediaBatch;
     /**
      * The product's parsed epochs as seconds since J2000 (the product's own
      * time scale), ascending. This is the exact axis [`Sp3.interpolate`]
@@ -5766,6 +6023,10 @@ export class Sp3 {
      * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
      */
     observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
+    /**
+     * Build deterministic precise-interpolant artifact bytes from this SP3 product.
+     */
+    preciseInterpolantArtifactBytes(): Uint8Array;
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -5793,6 +6054,22 @@ export class Sp3 {
      * or failed. Delegates to the serial reference batch kernel.
      */
     solveSppBatch(epochs: any, options: any): SppBatchSolution;
+    /**
+     * Run SPP and attach a Doppler velocity/clock-drift solve when Doppler rows solve.
+     *
+     * `request` is the normal SPP request object. `dopplerObservations` is an
+     * array of `{ satelliteId, dopplerHz, carrierHz, satClockDriftSS? }`. The
+     * returned receiver solution carries `rxClockDriftSS` when velocity solved.
+     */
+    solveSppWithDopplerVelocity(request: any, doppler_observations: any): SppDopplerSolution;
+    /**
+     * Solve one static receiver position from multiple SPP-shaped epochs.
+     *
+     * `epochs` is an array of SPP request objects. `options` accepts
+     * `{ initialPositionM?, withGeodetic?, robust? }` and returns shared
+     * position, per-epoch clocks, covariance, residual, and influence surfaces.
+     */
+    solveStatic(epochs: any, options: any): StaticSolution;
     /**
      * Run the core robust-reweighted SPP driver under the RAIM/FDE exclusion loop.
      *
@@ -6248,6 +6525,27 @@ export class SppBatchSolution {
     readonly count: number;
 }
 
+/**
+ * Position solution with an optional Doppler velocity solve.
+ */
+export class SppDopplerSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Receiver position, clock, and covariance solution.
+     */
+    readonly receiver: SppSolution;
+    /**
+     * Doppler-derived receiver velocity and clock drift, if the velocity rows solved.
+     */
+    readonly velocity: VelocitySolution | undefined;
+    /**
+     * Velocity-solve failure text when Doppler rows were present but unusable.
+     */
+    readonly velocityError: string | undefined;
+}
+
 /**
  * The result of an SPP solve.
  */
@@ -6273,6 +6571,14 @@ export class SppSolution {
      * are returned as a singular-geometry `Error` rather than a solution.
      */
     readonly geometryQuality: GeometryQuality;
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEcefM2: Float64Array;
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEnuM2: Float64Array;
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      */
@@ -6289,6 +6595,10 @@ export class SppSolution {
      * Post-fit residuals, metres, index-aligned to `usedSats`.
      */
     readonly residualsM: Float64Array;
+    /**
+     * Receiver clock drift in seconds per second when a Doppler solve was fused.
+     */
+    readonly rxClockDriftSS: number | undefined;
     /**
      * Receiver clock bias, seconds.
      */
@@ -6342,6 +6652,121 @@ export enum SsrSource {
     GalileoHas = 1,
 }
 
+/**
+ * Status for a leave-one-out static positioning diagnostic.
+ */
+export enum StaticInfluenceStatus {
+    /**
+     * The diagnostic solve completed.
+     */
+    Solved = 0,
+    /**
+     * The omitted subset left too few measurements.
+     */
+    TooFewMeasurements = 1,
+    /**
+     * The diagnostic geometry was singular.
+     */
+    SingularGeometry = 2,
+    /**
+     * Input validation failed for the diagnostic subset.
+     */
+    InvalidInput = 3,
+    /**
+     * Ephemeris was unavailable for the diagnostic subset.
+     */
+    EphemerisUnavailable = 4,
+    /**
+     * The diagnostic subset failed for another reason.
+     */
+    SolveFailed = 5,
+}
+
+/**
+ * Multi-epoch static receiver solution.
+ */
+export class StaticSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * `[latRad, lonRad, heightM]` when geodetic output was requested.
+     */
+    readonly geodetic: Float64Array | undefined;
+    /**
+     * Geometry observability and covariance-validation diagnostics.
+     */
+    readonly geometryQuality: GeometryQuality;
+    /**
+     * Solver iteration, convergence, and redundancy metadata.
+     */
+    readonly metadata: any;
+    /**
+     * Epoch-local receiver clocks as `{ epochIndex, system, clockS }[]`.
+     */
+    readonly perEpochClocks: any;
+    /**
+     * Leave-one-epoch-out diagnostics.
+     */
+    readonly perEpochInfluence: any;
+    /**
+     * Leave-one-satellite-out diagnostics across every epoch.
+     */
+    readonly perSatelliteBatchInfluence: any;
+    /**
+     * Leave-one-satellite-out diagnostics per epoch.
+     */
+    readonly perSatelliteInfluence: any;
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEcefM2: Float64Array;
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEnuM2: Float64Array;
+    /**
+     * ECEF position as `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Rejected satellites grouped by input epoch.
+     */
+    readonly rejectedSats: any;
+    /**
+     * Root-mean-square of the unweighted post-fit residuals, metres.
+     */
+    readonly residualRmsM: number;
+    /**
+     * Post-fit residuals as `{ epochIndex, satelliteId, residualM, ... }[]`.
+     */
+    readonly residuals: any;
+    /**
+     * Full state covariance, flat row-major square matrix in square metres.
+     */
+    readonly stateCovarianceM2: Float64Array;
+    /**
+     * State covariance matrix dimension.
+     */
+    readonly stateParameterCount: number;
+    /**
+     * Used satellite tokens grouped by input epoch.
+     */
+    readonly usedSats: any;
+    /**
+     * ECEF X, metres.
+     */
+    readonly xM: number;
+    /**
+     * ECEF Y, metres.
+     */
+    readonly yM: number;
+    /**
+     * ECEF Z, metres.
+     */
+    readonly zM: number;
+}
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -7033,6 +7458,10 @@ export class VelocitySolution {
      * Receiver speed, metres per second.
      */
     readonly speedMS: number;
+    /**
+     * Unit-variance covariance of `[vx, vy, vz, clockDrift]`, flat row-major.
+     */
+    readonly stateCovariance: Float64Array;
     /**
      * Satellite tokens contributing rows, in residual order.
      */
@@ -7713,6 +8142,11 @@ export function eirp(tx_power_dbm: number, tx_antenna_gain_dbi: number): number;
  */
 export function ellipsoidalHeightM(orthometric_height_m: number, lat_rad: number, lon_rad: number): number;
 
+/**
+ * Stable string label for an [`EmissionMediaStatus`] enum value.
+ */
+export function emissionMediaStatusLabel(status: EmissionMediaStatus): string;
+
 /**
  * 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
@@ -8124,6 +8558,49 @@ export function geodesicInverse(lat1_deg: number, lon1_deg: number, lat2_deg: nu
  */
 export function geodeticToEcef(geodetic: Float64Array): Float64Array;
 
+/**
+ * Containment probability using default probability options.
+ */
+export function geofenceContainmentProbability(vertices: Float64Array, lat_rad: number, lon_rad: number, height_m: number, uncertainty_value: any): number;
+
+/**
+ * Boolean containment for one position and flat vertex array.
+ */
+export function geofenceContains(vertices: Float64Array, lat_rad: number, lon_rad: number, height_m: number): boolean;
+
+/**
+ * Stable string label for a [`GeofenceCrossingKind`] enum value.
+ */
+export function geofenceCrossingKindLabel(kind: GeofenceCrossingKind): string;
+
+/**
+ * Probabilistic crossing detection with default hysteresis.
+ */
+export function geofenceCrossingProbability(vertices: Float64Array, samples: any, options: any): any;
+
+/**
+ * Stable string label for a [`GeofenceError`] enum value.
+ */
+export function geofenceErrorLabel(error: GeofenceError): string;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+ */
+export function geofenceFromVertices(vertices: Float64Array): Geofence;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 3D radian vertices.
+ *
+ * `vertices` is `[latRad, lonRad, heightM, ...]`. Heights are accepted but
+ * ignored by the core geofence model.
+ */
+export function geofenceFromVertices3d(vertices: Float64Array): Geofence;
+
+/**
+ * Stable string label for a [`GeofenceProbabilityMethod`] enum value.
+ */
+export function geofenceProbabilityMethodLabel(method: GeofenceProbabilityMethod): string;
+
 /**
  * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
  * position in radians, from the COARSE built-in global grid. Latitude is
@@ -8909,6 +9386,14 @@ export function observeSpkBody(station: any, epoch_unix_us: bigint, spk: Spk, na
  */
 export function oceanTideLoading(station_ecef_m: Float64Array, year: number, month: number, day: number, fractional_hour: number, amplitude_m: Float64Array, phase_deg: Float64Array): Float64Array;
 
+/**
+ * Open precise-interpolant artifact bytes as an evaluable in-memory product.
+ *
+ * The returned handle owns its byte buffer because JS byte slices cannot be
+ * borrowed across calls by this class boundary.
+ */
+export function openPreciseInterpolantArtifact(bytes: Uint8Array): PreciseInterpolantArtifact;
+
 /**
  * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
  *
@@ -9139,6 +9624,16 @@ export function pppCorrectionsWithCodeBias(sp3: Sp3, epochs: any, receiver_ecef_
  */
 export function preciseEphemerisSamplesFromSamples(samples: any): PreciseEphemerisSampleSource;
 
+/**
+ * Compute the precise-interpolant artifact file-level checksum for byte content.
+ */
+export function preciseInterpolantArtifactChecksum64(bytes: Uint8Array): bigint;
+
+/**
+ * Stable string label for a [`PreciseInterpolantArtifactError`] enum value.
+ */
+export function preciseInterpolantArtifactErrorLabel(error: PreciseInterpolantArtifactError): string;
+
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
  * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
@@ -9649,6 +10144,11 @@ export function solveRtkFloat(config: any): RtkFloatSolution;
  */
 export function solveSppSbas(broadcast: BroadcastEphemeris, store: SbasCorrectionStore, geo: string, request: any, mode?: string | null): SppSolution;
 
+/**
+ * Solve one static receiver position from multiple SPP-shaped epochs over SP3.
+ */
+export function solveStatic(sp3: Sp3, epochs: any, options: any): StaticSolution;
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -9739,6 +10239,11 @@ export function ssrCorrectedState(broadcast: BroadcastEphemeris, store: SsrCorre
  */
 export function ssrSourceLabel(source: SsrSource): string;
 
+/**
+ * Stable string label for a [`StaticInfluenceStatus`] enum value.
+ */
+export function staticInfluenceStatusLabel(status: StaticInfluenceStatus): string;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *