@neilberkman/sidereon 0.16.1 → 0.17.0

package/pkg-node/sidereon.js

@@ -4328,6 +4328,153 @@ class EllipsoidalHeightM {
 if (Symbol.dispose) EllipsoidalHeightM.prototype[Symbol.dispose] = EllipsoidalHeightM.prototype.free;
 exports.EllipsoidalHeightM = EllipsoidalHeightM;
 
+/**
+ * Contiguous state and media-correction arrays from one emission batch.
+ */
+class EmissionMediaBatch {
+    static __wrap(ptr) {
+        const obj = Object.create(EmissionMediaBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        EmissionMediaBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EmissionMediaBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_emissionmediabatch_free(ptr, 0);
+    }
+    /**
+     * Satellite clock offsets in seconds, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get clockS() {
+        const ret = wasm.emissionmediabatch_clockS(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Number of satellite rows in the batch.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.emissionmediabatch_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Per-row success and error messages as `{ ok, error }[]`.
+     * @returns {any}
+     */
+    get elementResults() {
+        const ret = wasm.emissionmediabatch_elementResults(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Error message for row `index`, or `undefined` when the row has no error.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    error(index) {
+        const ret = wasm.emissionmediabatch_error(this.__wbg_ptr, index);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Ionospheric slant group delays in metres, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get ionosphereSlantDelayM() {
+        const ret = wasm.emissionmediabatch_ionosphereSlantDelayM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * 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.
+     * @returns {Float64Array}
+     */
+    get positionEcefM() {
+        const ret = wasm.emissionmediabatch_positionEcefM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Per-row status labels, index-aligned with the numeric arrays.
+     * @returns {string[]}
+     */
+    get statusLabels() {
+        const ret = wasm.emissionmediabatch_statusLabels(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Per-row typed status values, index-aligned with the numeric arrays.
+     * @returns {any[]}
+     */
+    get statuses() {
+        const ret = wasm.emissionmediabatch_statuses(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Tropospheric slant delays in metres, with `NaN` for unavailable rows.
+     * @returns {Float64Array}
+     */
+    get troposphereDelayM() {
+        const ret = wasm.emissionmediabatch_troposphereDelayM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) EmissionMediaBatch.prototype[Symbol.dispose] = EmissionMediaBatch.prototype.free;
+exports.EmissionMediaBatch = EmissionMediaBatch;
+
+/**
+ * Per-satellite status for an emission media batch row.
+ * @enum {0 | 1 | 2 | 3}
+ */
+const EmissionMediaStatus = Object.freeze({
+    /**
+     * State, clock, and requested media corrections were produced.
+     */
+    Valid: 0, "0": "Valid",
+    /**
+     * The ephemeris product has no usable state for this satellite and epoch.
+     */
+    Gap: 1, "1": "Gap",
+    /**
+     * A state was available, but elevation was below the requested cutoff.
+     */
+    BelowElevationCutoff: 2, "2": "BelowElevationCutoff",
+    /**
+     * A non-gap scalar evaluation error occurred.
+     */
+    Error: 3, "3": "Error",
+});
+exports.EmissionMediaStatus = EmissionMediaStatus;
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -4953,6 +5100,205 @@ const GeodesicError = Object.freeze({
 });
 exports.GeodesicError = GeodesicError;
 
+/**
+ * A geodesic polygon fence on WGS84.
+ */
+class Geofence {
+    static __wrap(ptr) {
+        const obj = Object.create(Geofence.prototype);
+        obj.__wbg_ptr = ptr;
+        GeofenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeofenceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_geofence_free(ptr, 0);
+    }
+    /**
+     * Containment probability for one position and uncertainty object.
+     *
+     * `uncertainty.kind` is one of `"enuCovarianceM2"`, `"ecefCovarianceM2"`,
+     * `"cepRadiusM"`, or `"horizontalRadius"`. `options.method` is
+     * `"boundaryNormal"` or `"planarQuadrature"`.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @param {any} uncertainty_value
+     * @param {any} options
+     * @returns {number}
+     */
+    containmentProbability(lat_rad, lon_rad, height_m, uncertainty_value, options) {
+        const ret = wasm.geofence_containmentProbability(this.__wbg_ptr, lat_rad, lon_rad, height_m, uncertainty_value, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Boolean containment for one WGS84 geodetic position.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {boolean}
+     */
+    contains(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_contains(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * 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.
+     * @param {any} samples
+     * @param {any} options
+     * @returns {any}
+     */
+    crossingProbability(samples, options) {
+        const ret = wasm.geofence_crossingProbability(this.__wbg_ptr, samples, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Signed distance to the fence boundary in metres.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {number}
+     */
+    distanceToBoundary(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_distanceToBoundary(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Number of polygon edges.
+     * @returns {number}
+     */
+    get edgeCount() {
+        const ret = wasm.geofence_edgeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+     *
+     * `vertices` is `[latRad, lonRad, ...]`. Use `geofenceFromVertices3d`
+     * for `[latRad, lonRad, heightM, ...]` rows.
+     * @param {Float64Array} vertices
+     */
+    constructor(vertices) {
+        const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geofence_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        GeofenceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Whether the core small-region planar path can evaluate this position.
+     * @param {number} lat_rad
+     * @param {number} lon_rad
+     * @param {number} height_m
+     * @returns {boolean}
+     */
+    planarFastPathApplies(lat_rad, lon_rad, height_m) {
+        const ret = wasm.geofence_planarFastPathApplies(this.__wbg_ptr, lat_rad, lon_rad, height_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Fence vertices in open-polygon form as flat `[latRad, lonRad, heightM]` rows.
+     * @returns {Float64Array}
+     */
+    get vertices() {
+        const ret = wasm.geofence_vertices(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) Geofence.prototype[Symbol.dispose] = Geofence.prototype.free;
+exports.Geofence = Geofence;
+
+/**
+ * Geofence crossing event direction.
+ * @enum {0 | 1}
+ */
+const GeofenceCrossingKind = Object.freeze({
+    /**
+     * The sample sequence entered the fence.
+     */
+    Entered: 0, "0": "Entered",
+    /**
+     * The sample sequence left the fence.
+     */
+    Left: 1, "1": "Left",
+});
+exports.GeofenceCrossingKind = GeofenceCrossingKind;
+
+/**
+ * Geofence construction and evaluation error variants.
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+const GeofenceError = Object.freeze({
+    /**
+     * Fewer than three distinct vertices were supplied.
+     */
+    TooFewVertices: 0, "0": "TooFewVertices",
+    /**
+     * A geofence input value was outside its domain.
+     */
+    InvalidInput: 1, "1": "InvalidInput",
+    /**
+     * The geodesic direct or inverse calculation failed.
+     */
+    Geodesic: 2, "2": "Geodesic",
+    /**
+     * ECEF covariance rotation failed.
+     */
+    Dop: 3, "3": "Dop",
+    /**
+     * Covariance or radius validation failed.
+     */
+    ErrorMetrics: 4, "4": "ErrorMetrics",
+});
+exports.GeofenceError = GeofenceError;
+
+/**
+ * Probability integration method for geofence uncertainty.
+ * @enum {0 | 1}
+ */
+const GeofenceProbabilityMethod = Object.freeze({
+    /**
+     * Gaussian half-space approximation from boundary distance and normal variance.
+     */
+    BoundaryNormal: 0, "0": "BoundaryNormal",
+    /**
+     * Fixed quadrature over the local planarized fence.
+     */
+    PlanarQuadrature: 1, "1": "PlanarQuadrature",
+});
+exports.GeofenceProbabilityMethod = GeofenceProbabilityMethod;
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -12260,53 +12606,174 @@ if (Symbol.dispose) PreciseEphemerisSampleSource.prototype[Symbol.dispose] = Pre
 exports.PreciseEphemerisSampleSource = PreciseEphemerisSampleSource;
 
 /**
- * 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`].
+ * Evaluable precise-interpolant artifact opened from canonical store bytes.
  */
-class PredictBatch {
+class PreciseInterpolantArtifact {
     static __wrap(ptr) {
-        const obj = Object.create(PredictBatch.prototype);
+        const obj = Object.create(PreciseInterpolantArtifact.prototype);
         obj.__wbg_ptr = ptr;
-        PredictBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        PreciseInterpolantArtifactFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PredictBatchFinalization.unregister(this);
+        PreciseInterpolantArtifactFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_predictbatch_free(ptr, 0);
+        wasm.__wbg_preciseinterpolantartifact_free(ptr, 0);
     }
     /**
-     * Number of requests in the batch.
+     * Number of bytes retained by this artifact handle.
      * @returns {number}
      */
-    get count() {
-        const ret = wasm.predictbatch_count(this.__wbg_ptr);
+    get byteLength() {
+        const ret = wasm.preciseinterpolantartifact_byteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * The failure message for request `index`, or `undefined` when it
-     * succeeded. Throws a `RangeError` for an out-of-range index.
-     * @param {number} index
-     * @returns {string | undefined}
+     * File-level artifact checksum.
+     * @returns {bigint}
      */
-    error(index) {
-        const ret = wasm.predictbatch_error(this.__wbg_ptr, index);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v1;
+    get checksum64() {
+        const ret = wasm.preciseinterpolantartifact_checksum64(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Evaluate one satellite state at a J2000-second epoch.
+     * @param {string} satellite
+     * @param {number} j2000_seconds
+     * @returns {Sp3State}
+     */
+    evaluate(satellite, j2000_seconds) {
+        const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.preciseinterpolantartifact_evaluate(this.__wbg_ptr, ptr0, len0, j2000_seconds);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Sp3State.__wrap(ret[0]);
+    }
+    /**
+     * Satellite tokens present in the artifact, ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseinterpolantartifact_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Artifact time scale label from the stored epoch axis.
+     * @returns {string}
+     */
+    get timeScale() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preciseinterpolantartifact_timeScale(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) PreciseInterpolantArtifact.prototype[Symbol.dispose] = PreciseInterpolantArtifact.prototype.free;
+exports.PreciseInterpolantArtifact = PreciseInterpolantArtifact;
+
+/**
+ * Error category for precise-interpolant artifact open or serialization.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
+ */
+const PreciseInterpolantArtifactError = Object.freeze({
+    /**
+     * File I/O failed in the core artifact API.
+     */
+    Io: 0, "0": "Io",
+    /**
+     * Artifact bytes could not be parsed.
+     */
+    Parse: 1, "1": "Parse",
+    /**
+     * The artifact version tag is unsupported.
+     */
+    UnsupportedVersion: 2, "2": "UnsupportedVersion",
+    /**
+     * The artifact time-scale tag is unsupported.
+     */
+    UnsupportedTimeScale: 3, "3": "UnsupportedTimeScale",
+    /**
+     * A satellite-system tag is unsupported.
+     */
+    UnsupportedSatelliteSystem: 4, "4": "UnsupportedSatelliteSystem",
+    /**
+     * A satellite appears more than once in the artifact index.
+     */
+    DuplicateSatellite: 5, "5": "DuplicateSatellite",
+    /**
+     * The artifact file-level checksum did not match.
+     */
+    Checksum: 6, "6": "Checksum",
+    /**
+     * A satellite payload checksum did not match its index record.
+     */
+    SatelliteChecksum: 7, "7": "SatelliteChecksum",
+});
+exports.PreciseInterpolantArtifactError = PreciseInterpolantArtifactError;
+
+/**
+ * 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`].
+ */
+class PredictBatch {
+    static __wrap(ptr) {
+        const obj = Object.create(PredictBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        PredictBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PredictBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_predictbatch_free(ptr, 0);
+    }
+    /**
+     * Number of requests in the batch.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.predictbatch_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The failure message for request `index`, or `undefined` when it
+     * succeeded. Throws a `RangeError` for an out-of-range index.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    error(index) {
+        const ret = wasm.predictbatch_error(this.__wbg_ptr, index);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
     /**
      * Whether request `index` produced observables. Throws a `RangeError` for
@@ -14689,6 +15156,57 @@ class Sp3 {
         }
         return DgnssSolution.__wrap(ret[0]);
     }
+    /**
+     * 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 }`.
+     * @param {string[]} satellites
+     * @param {Float64Array} emission_epochs_j2000_s
+     * @param {Float64Array} receiver_ecef_m
+     * @param {any} options
+     * @returns {EmissionMediaBatch}
+     */
+    emissionMediaBatch(satellites, emission_epochs_j2000_s, receiver_ecef_m, options) {
+        const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(emission_epochs_j2000_s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.sp3_emissionMediaBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EmissionMediaBatch.__wrap(ret[0]);
+    }
+    /**
+     * Evaluate emission-time state plus IONEX/troposphere media corrections.
+     *
+     * `options.ionosphere` defaults to `true` on this IONEX-bearing path.
+     * `options.troposphere` defaults to `false`.
+     * @param {Ionex} ionex
+     * @param {string[]} satellites
+     * @param {Float64Array} emission_epochs_j2000_s
+     * @param {Float64Array} receiver_ecef_m
+     * @param {any} options
+     * @returns {EmissionMediaBatch}
+     */
+    emissionMediaBatchIonex(ionex, satellites, emission_epochs_j2000_s, receiver_ecef_m, options) {
+        _assertClass(ionex, Ionex);
+        const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(emission_epochs_j2000_s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.sp3_emissionMediaBatchIonex(this.__wbg_ptr, ionex.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return EmissionMediaBatch.__wrap(ret[0]);
+    }
     /**
      * Number of epochs in the product.
      * @returns {number}
@@ -14787,6 +15305,19 @@ class Sp3 {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Build deterministic precise-interpolant artifact bytes from this SP3 product.
+     * @returns {Uint8Array}
+     */
+    preciseInterpolantArtifactBytes() {
+        const ret = wasm.sp3_preciseInterpolantArtifactBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -14850,6 +15381,40 @@ class Sp3 {
         }
         return SppBatchSolution.__wrap(ret[0]);
     }
+    /**
+     * 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.
+     * @param {any} request
+     * @param {any} doppler_observations
+     * @returns {SppDopplerSolution}
+     */
+    solveSppWithDopplerVelocity(request, doppler_observations) {
+        const ret = wasm.sp3_solveSppWithDopplerVelocity(this.__wbg_ptr, request, doppler_observations);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SppDopplerSolution.__wrap(ret[0]);
+    }
+    /**
+     * 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.
+     * @param {any} epochs
+     * @param {any} options
+     * @returns {StaticSolution}
+     */
+    solveStatic(epochs, options) {
+        const ret = wasm.sp3_solveStatic(this.__wbg_ptr, epochs, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StaticSolution.__wrap(ret[0]);
+    }
     /**
      * Run the core robust-reweighted SPP driver under the RAIM/FDE exclusion loop.
      *
@@ -16051,6 +16616,59 @@ class SppBatchSolution {
 if (Symbol.dispose) SppBatchSolution.prototype[Symbol.dispose] = SppBatchSolution.prototype.free;
 exports.SppBatchSolution = SppBatchSolution;
 
+/**
+ * Position solution with an optional Doppler velocity solve.
+ */
+class SppDopplerSolution {
+    static __wrap(ptr) {
+        const obj = Object.create(SppDopplerSolution.prototype);
+        obj.__wbg_ptr = ptr;
+        SppDopplerSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SppDopplerSolutionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sppdopplersolution_free(ptr, 0);
+    }
+    /**
+     * Receiver position, clock, and covariance solution.
+     * @returns {SppSolution}
+     */
+    get receiver() {
+        const ret = wasm.sppdopplersolution_receiver(this.__wbg_ptr);
+        return SppSolution.__wrap(ret);
+    }
+    /**
+     * Doppler-derived receiver velocity and clock drift, if the velocity rows solved.
+     * @returns {VelocitySolution | undefined}
+     */
+    get velocity() {
+        const ret = wasm.sppdopplersolution_velocity(this.__wbg_ptr);
+        return ret === 0 ? undefined : VelocitySolution.__wrap(ret);
+    }
+    /**
+     * Velocity-solve failure text when Doppler rows were present but unusable.
+     * @returns {string | undefined}
+     */
+    get velocityError() {
+        const ret = wasm.sppdopplersolution_velocityError(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) SppDopplerSolution.prototype[Symbol.dispose] = SppDopplerSolution.prototype.free;
+exports.SppDopplerSolution = SppDopplerSolution;
+
 /**
  * The result of an SPP solve.
  */
@@ -16106,6 +16724,26 @@ class SppSolution {
         const ret = wasm.sppsolution_geometryQuality(this.__wbg_ptr);
         return GeometryQuality.__wrap(ret);
     }
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEcefM2() {
+        const ret = wasm.sppsolution_positionCovarianceEcefM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEnuM2() {
+        const ret = wasm.sppsolution_positionCovarianceEnuM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      * @returns {Float64Array}
@@ -16142,6 +16780,14 @@ class SppSolution {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Receiver clock drift in seconds per second when a Doppler solve was fused.
+     * @returns {number | undefined}
+     */
+    get rxClockDriftSS() {
+        const ret = wasm.sppsolution_rxClockDriftSS(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
     /**
      * Receiver clock bias, seconds.
      * @returns {number}
@@ -16243,57 +16889,302 @@ class SsrCorrectionStore {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    constructor() {
-        const ret = wasm.ssrcorrectionstore_new();
-        this.__wbg_ptr = ret;
-        SsrCorrectionStoreFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    constructor() {
+        const ret = wasm.ssrcorrectionstore_new();
+        this.__wbg_ptr = ret;
+        SsrCorrectionStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} sat
+     * @returns {any}
+     */
+    orbit(sat) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ssrcorrectionstore_orbit(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} sat
+     * @returns {number | undefined}
+     */
+    uraIndex(sat) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ssrcorrectionstore_uraIndex(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0xFFFFFF ? undefined : ret[0];
+    }
+}
+if (Symbol.dispose) SsrCorrectionStore.prototype[Symbol.dispose] = SsrCorrectionStore.prototype.free;
+exports.SsrCorrectionStore = SsrCorrectionStore;
+
+/**
+ * Source stream for engineering-unit SSR corrections.
+ * @enum {0 | 1}
+ */
+const SsrSource = Object.freeze({
+    /**
+     * RTCM SSR messages.
+     */
+    RtcmSsr: 0, "0": "RtcmSsr",
+    /**
+     * Galileo High Accuracy Service messages.
+     */
+    GalileoHas: 1, "1": "GalileoHas",
+});
+exports.SsrSource = SsrSource;
+
+/**
+ * Status for a leave-one-out static positioning diagnostic.
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+const StaticInfluenceStatus = Object.freeze({
+    /**
+     * The diagnostic solve completed.
+     */
+    Solved: 0, "0": "Solved",
+    /**
+     * The omitted subset left too few measurements.
+     */
+    TooFewMeasurements: 1, "1": "TooFewMeasurements",
+    /**
+     * The diagnostic geometry was singular.
+     */
+    SingularGeometry: 2, "2": "SingularGeometry",
+    /**
+     * Input validation failed for the diagnostic subset.
+     */
+    InvalidInput: 3, "3": "InvalidInput",
+    /**
+     * Ephemeris was unavailable for the diagnostic subset.
+     */
+    EphemerisUnavailable: 4, "4": "EphemerisUnavailable",
+    /**
+     * The diagnostic subset failed for another reason.
+     */
+    SolveFailed: 5, "5": "SolveFailed",
+});
+exports.StaticInfluenceStatus = StaticInfluenceStatus;
+
+/**
+ * Multi-epoch static receiver solution.
+ */
+class StaticSolution {
+    static __wrap(ptr) {
+        const obj = Object.create(StaticSolution.prototype);
+        obj.__wbg_ptr = ptr;
+        StaticSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StaticSolutionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_staticsolution_free(ptr, 0);
+    }
+    /**
+     * `[latRad, lonRad, heightM]` when geodetic output was requested.
+     * @returns {Float64Array | undefined}
+     */
+    get geodetic() {
+        const ret = wasm.staticsolution_geodetic(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Geometry observability and covariance-validation diagnostics.
+     * @returns {GeometryQuality}
+     */
+    get geometryQuality() {
+        const ret = wasm.staticsolution_geometryQuality(this.__wbg_ptr);
+        return GeometryQuality.__wrap(ret);
+    }
+    /**
+     * Solver iteration, convergence, and redundancy metadata.
+     * @returns {any}
+     */
+    get metadata() {
+        const ret = wasm.staticsolution_metadata(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Epoch-local receiver clocks as `{ epochIndex, system, clockS }[]`.
+     * @returns {any}
+     */
+    get perEpochClocks() {
+        const ret = wasm.staticsolution_perEpochClocks(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-epoch-out diagnostics.
+     * @returns {any}
+     */
+    get perEpochInfluence() {
+        const ret = wasm.staticsolution_perEpochInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-satellite-out diagnostics across every epoch.
+     * @returns {any}
+     */
+    get perSatelliteBatchInfluence() {
+        const ret = wasm.staticsolution_perSatelliteBatchInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Leave-one-satellite-out diagnostics per epoch.
+     * @returns {any}
+     */
+    get perSatelliteInfluence() {
+        const ret = wasm.staticsolution_perSatelliteInfluence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEcefM2() {
+        const ret = wasm.staticsolution_positionCovarianceEcefM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     * @returns {Float64Array}
+     */
+    get positionCovarianceEnuM2() {
+        const ret = wasm.staticsolution_positionCovarianceEnuM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * ECEF position as `[x, y, z]`, metres.
+     * @returns {Float64Array}
+     */
+    get positionM() {
+        const ret = wasm.staticsolution_positionM(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Rejected satellites grouped by input epoch.
+     * @returns {any}
+     */
+    get rejectedSats() {
+        const ret = wasm.staticsolution_rejectedSats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Root-mean-square of the unweighted post-fit residuals, metres.
+     * @returns {number}
+     */
+    get residualRmsM() {
+        const ret = wasm.staticsolution_residualRmsM(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {string} sat
+     * Post-fit residuals as `{ epochIndex, satelliteId, residualM, ... }[]`.
      * @returns {any}
      */
-    orbit(sat) {
-        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ssrcorrectionstore_orbit(this.__wbg_ptr, ptr0, len0);
+    get residuals() {
+        const ret = wasm.staticsolution_residuals(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @param {string} sat
-     * @returns {number | undefined}
+     * Full state covariance, flat row-major square matrix in square metres.
+     * @returns {Float64Array}
      */
-    uraIndex(sat) {
-        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ssrcorrectionstore_uraIndex(this.__wbg_ptr, ptr0, len0);
+    get stateCovarianceM2() {
+        const ret = wasm.staticsolution_stateCovarianceM2(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * State covariance matrix dimension.
+     * @returns {number}
+     */
+    get stateParameterCount() {
+        const ret = wasm.staticsolution_stateParameterCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Used satellite tokens grouped by input epoch.
+     * @returns {any}
+     */
+    get usedSats() {
+        const ret = wasm.staticsolution_usedSats(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0] === 0xFFFFFF ? undefined : ret[0];
+        return takeFromExternrefTable0(ret[0]);
     }
-}
-if (Symbol.dispose) SsrCorrectionStore.prototype[Symbol.dispose] = SsrCorrectionStore.prototype.free;
-exports.SsrCorrectionStore = SsrCorrectionStore;
-
-/**
- * Source stream for engineering-unit SSR corrections.
- * @enum {0 | 1}
- */
-const SsrSource = Object.freeze({
     /**
-     * RTCM SSR messages.
+     * ECEF X, metres.
+     * @returns {number}
      */
-    RtcmSsr: 0, "0": "RtcmSsr",
+    get xM() {
+        const ret = wasm.staticsolution_xM(this.__wbg_ptr);
+        return ret;
+    }
     /**
-     * Galileo High Accuracy Service messages.
+     * ECEF Y, metres.
+     * @returns {number}
      */
-    GalileoHas: 1, "1": "GalileoHas",
-});
-exports.SsrSource = SsrSource;
+    get yM() {
+        const ret = wasm.staticsolution_yM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * ECEF Z, metres.
+     * @returns {number}
+     */
+    get zM() {
+        const ret = wasm.staticsolution_zM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) StaticSolution.prototype[Symbol.dispose] = StaticSolution.prototype.free;
+exports.StaticSolution = StaticSolution;
 
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
@@ -17998,6 +18889,16 @@ class VelocitySolution {
         const ret = wasm.velocitysolution_speedMS(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Unit-variance covariance of `[vx, vy, vz, clockDrift]`, flat row-major.
+     * @returns {Float64Array}
+     */
+    get stateCovariance() {
+        const ret = wasm.velocitysolution_stateCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Satellite tokens contributing rows, in residual order.
      * @returns {string[]}
@@ -19759,6 +20660,25 @@ function ellipsoidalHeightM(orthometric_height_m, lat_rad, lon_rad) {
 }
 exports.ellipsoidalHeightM = ellipsoidalHeightM;
 
+/**
+ * Stable string label for an [`EmissionMediaStatus`] enum value.
+ * @param {EmissionMediaStatus} status
+ * @returns {string}
+ */
+function emissionMediaStatusLabel(status) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.emissionMediaStatusLabel(status);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.emissionMediaStatusLabel = emissionMediaStatusLabel;
+
 /**
  * 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
@@ -20834,6 +21754,155 @@ function geodeticToEcef(geodetic) {
 }
 exports.geodeticToEcef = geodeticToEcef;
 
+/**
+ * Containment probability using default probability options.
+ * @param {Float64Array} vertices
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @param {number} height_m
+ * @param {any} uncertainty_value
+ * @returns {number}
+ */
+function geofenceContainmentProbability(vertices, lat_rad, lon_rad, height_m, uncertainty_value) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceContainmentProbability(ptr0, len0, lat_rad, lon_rad, height_m, uncertainty_value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.geofenceContainmentProbability = geofenceContainmentProbability;
+
+/**
+ * Boolean containment for one position and flat vertex array.
+ * @param {Float64Array} vertices
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @param {number} height_m
+ * @returns {boolean}
+ */
+function geofenceContains(vertices, lat_rad, lon_rad, height_m) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceContains(ptr0, len0, lat_rad, lon_rad, height_m);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.geofenceContains = geofenceContains;
+
+/**
+ * Stable string label for a [`GeofenceCrossingKind`] enum value.
+ * @param {GeofenceCrossingKind} kind
+ * @returns {string}
+ */
+function geofenceCrossingKindLabel(kind) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceCrossingKindLabel(kind);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceCrossingKindLabel = geofenceCrossingKindLabel;
+
+/**
+ * Probabilistic crossing detection with default hysteresis.
+ * @param {Float64Array} vertices
+ * @param {any} samples
+ * @param {any} options
+ * @returns {any}
+ */
+function geofenceCrossingProbability(vertices, samples, options) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceCrossingProbability(ptr0, len0, samples, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.geofenceCrossingProbability = geofenceCrossingProbability;
+
+/**
+ * Stable string label for a [`GeofenceError`] enum value.
+ * @param {GeofenceError} error
+ * @returns {string}
+ */
+function geofenceErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceErrorLabel = geofenceErrorLabel;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+ * @param {Float64Array} vertices
+ * @returns {Geofence}
+ */
+function geofenceFromVertices(vertices) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceFromVertices(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Geofence.__wrap(ret[0]);
+}
+exports.geofenceFromVertices = geofenceFromVertices;
+
+/**
+ * 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.
+ * @param {Float64Array} vertices
+ * @returns {Geofence}
+ */
+function geofenceFromVertices3d(vertices) {
+    const ptr0 = passArrayF64ToWasm0(vertices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.geofenceFromVertices3d(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Geofence.__wrap(ret[0]);
+}
+exports.geofenceFromVertices3d = geofenceFromVertices3d;
+
+/**
+ * Stable string label for a [`GeofenceProbabilityMethod`] enum value.
+ * @param {GeofenceProbabilityMethod} method
+ * @returns {string}
+ */
+function geofenceProbabilityMethodLabel(method) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geofenceProbabilityMethodLabel(method);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.geofenceProbabilityMethodLabel = geofenceProbabilityMethodLabel;
+
 /**
  * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
  * position in radians, from the COARSE built-in global grid. Latitude is
@@ -23106,6 +24175,25 @@ function oceanTideLoading(station_ecef_m, year, month, day, fractional_hour, amp
 }
 exports.oceanTideLoading = oceanTideLoading;
 
+/**
+ * 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.
+ * @param {Uint8Array} bytes
+ * @returns {PreciseInterpolantArtifact}
+ */
+function openPreciseInterpolantArtifact(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openPreciseInterpolantArtifact(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PreciseInterpolantArtifact.__wrap(ret[0]);
+}
+exports.openPreciseInterpolantArtifact = openPreciseInterpolantArtifact;
+
 /**
  * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
  *
@@ -23777,6 +24865,38 @@ function preciseEphemerisSamplesFromSamples(samples) {
 }
 exports.preciseEphemerisSamplesFromSamples = preciseEphemerisSamplesFromSamples;
 
+/**
+ * Compute the precise-interpolant artifact file-level checksum for byte content.
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+function preciseInterpolantArtifactChecksum64(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.preciseInterpolantArtifactChecksum64(ptr0, len0);
+    return BigInt.asUintN(64, ret);
+}
+exports.preciseInterpolantArtifactChecksum64 = preciseInterpolantArtifactChecksum64;
+
+/**
+ * Stable string label for a [`PreciseInterpolantArtifactError`] enum value.
+ * @param {PreciseInterpolantArtifactError} error
+ * @returns {string}
+ */
+function preciseInterpolantArtifactErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.preciseInterpolantArtifactErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.preciseInterpolantArtifactErrorLabel = preciseInterpolantArtifactErrorLabel;
+
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
  * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
@@ -25249,6 +26369,23 @@ function solveSppSbas(broadcast, store, geo, request, mode) {
 }
 exports.solveSppSbas = solveSppSbas;
 
+/**
+ * Solve one static receiver position from multiple SPP-shaped epochs over SP3.
+ * @param {Sp3} sp3
+ * @param {any} epochs
+ * @param {any} options
+ * @returns {StaticSolution}
+ */
+function solveStatic(sp3, epochs, options) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.solveStatic(sp3.__wbg_ptr, epochs, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return StaticSolution.__wrap(ret[0]);
+}
+exports.solveStatic = solveStatic;
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -25492,6 +26629,25 @@ function ssrSourceLabel(source) {
 }
 exports.ssrSourceLabel = ssrSourceLabel;
 
+/**
+ * Stable string label for a [`StaticInfluenceStatus`] enum value.
+ * @param {StaticInfluenceStatus} status
+ * @returns {string}
+ */
+function staticInfluenceStatusLabel(status) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.staticInfluenceStatusLabel(status);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.staticInfluenceStatusLabel = staticInfluenceStatusLabel;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *
@@ -26303,6 +27459,10 @@ function __wbg_get_imports() {
             const ret = String.fromCodePoint(arg0 >>> 0);
             return ret;
         }, arguments); },
+        __wbg_from_13e323c65fc8f464: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
         __wbg_get_507a50627bffa49b: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -26762,6 +27922,9 @@ const Egm96FifteenMinuteGeoidFinalization = (typeof FinalizationRegistry === 'un
 const EllipsoidalHeightMFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ellipsoidalheightm_free(ptr, 1));
+const EmissionMediaBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_emissionmediabatch_free(ptr, 1));
 const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_encounterframe_free(ptr, 1));
@@ -26789,6 +27952,9 @@ const FrameScannerFinalization = (typeof FinalizationRegistry === 'undefined')
 const FrameStatesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_framestates_free(ptr, 1));
+const GeofenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_geofence_free(ptr, 1));
 const GeoidGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geoidgrid_free(ptr, 1));
@@ -27002,6 +28168,9 @@ const PreciseEphemerisInterpolantFinalization = (typeof FinalizationRegistry ===
 const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));
+const PreciseInterpolantArtifactFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseinterpolantartifact_free(ptr, 1));
 const PredictBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_predictbatch_free(ptr, 1));
@@ -27128,12 +28297,18 @@ const SpkStateFinalization = (typeof FinalizationRegistry === 'undefined')
 const SppBatchSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sppbatchsolution_free(ptr, 1));
+const SppDopplerSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sppdopplersolution_free(ptr, 1));
 const SppSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sppsolution_free(ptr, 1));
 const SsrCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ssrcorrectionstore_free(ptr, 1));
+const StaticSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_staticsolution_free(ptr, 1));
 const SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sunmoon_free(ptr, 1));