@neilberkman/sidereon 0.9.1 → 0.10.0

package/pkg-node/sidereon.js

@@ -594,6 +594,146 @@ class AtmosphereDensity {
 if (Symbol.dispose) AtmosphereDensity.prototype[Symbol.dispose] = AtmosphereDensity.prototype.free;
 exports.AtmosphereDensity = AtmosphereDensity;
 
+class BiasSet {
+    static __wrap(ptr) {
+        const obj = Object.create(BiasSet.prototype);
+        obj.__wbg_ptr = ptr;
+        BiasSetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BiasSetFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_biasset_free(ptr, 0);
+    }
+    /**
+     * @param {string} sat
+     * @param {string} used_obs1
+     * @param {string} used_obs2
+     * @param {number} freq1_hz
+     * @param {number} freq2_hz
+     * @param {number | null | undefined} glonass_channel
+     * @param {string} clock_ref_obs1
+     * @param {string} clock_ref_obs2
+     * @param {number} epoch_j2000_s
+     * @param {string | null} [time_scale]
+     * @returns {number | undefined}
+     */
+    codeBiasModelM(sat, used_obs1, used_obs2, freq1_hz, freq2_hz, glonass_channel, clock_ref_obs1, clock_ref_obs2, epoch_j2000_s, time_scale) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(used_obs1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(used_obs2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(clock_ref_obs1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(clock_ref_obs2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        const ret = wasm.biasset_codeBiasModelM(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, freq1_hz, freq2_hz, isLikeNone(glonass_channel) ? 0xFFFFFF : glonass_channel, ptr3, len3, ptr4, len4, epoch_j2000_s, ptr5, len5);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {string} sat
+     * @param {string} obs1
+     * @param {string} obs2
+     * @param {number} epoch_j2000_s
+     * @param {string | null} [time_scale]
+     * @returns {number | undefined}
+     */
+    codeDsbSeconds(sat, obs1, obs2, epoch_j2000_s, time_scale) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(obs1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(obs2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.biasset_codeDsbSeconds(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, epoch_j2000_s, ptr3, len3);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {string} sat
+     * @param {string} obs
+     * @param {number} epoch_j2000_s
+     * @param {string | null} [time_scale]
+     * @returns {number | undefined}
+     */
+    codeOsbSeconds(sat, obs, epoch_j2000_s, time_scale) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(obs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.biasset_codeOsbSeconds(this.__wbg_ptr, ptr0, len0, ptr1, len1, epoch_j2000_s, ptr2, len2);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {string} sat
+     * @param {string} obs
+     * @param {number} epoch_j2000_s
+     * @param {string | null} [time_scale]
+     * @returns {number | undefined}
+     */
+    phaseOsbCycles(sat, obs, epoch_j2000_s, time_scale) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(obs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.biasset_phaseOsbCycles(this.__wbg_ptr, ptr0, len0, ptr1, len1, epoch_j2000_s, ptr2, len2);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @returns {number}
+     */
+    get recordCount() {
+        const ret = wasm.biasset_recordCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get records() {
+        const ret = wasm.biasset_records(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get skippedRecords() {
+        const ret = wasm.biasset_skippedRecords(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BiasSet.prototype[Symbol.dispose] = BiasSet.prototype.free;
+exports.BiasSet = BiasSet;
+
 /**
  * A parsed broadcast ephemeris store from a RINEX NAV file. `records` are the
  * usable GPS/Galileo/BeiDou records selected by the core default SPP policy.
@@ -3153,6 +3293,162 @@ class DopplerShift {
 if (Symbol.dispose) DopplerShift.prototype[Symbol.dispose] = DopplerShift.prototype.free;
 exports.DopplerShift = DopplerShift;
 
+class DragForce {
+    static __wrap(ptr) {
+        const obj = Object.create(DragForce.prototype);
+        obj.__wbg_ptr = ptr;
+        DragForceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DragForceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dragforce_free(ptr, 0);
+    }
+    /**
+     * @param {number} epoch_s
+     * @param {Float64Array} position_km
+     * @param {Float64Array} velocity_km_s
+     * @returns {Float64Array}
+     */
+    acceleration(epoch_s, position_km, velocity_km_s) {
+        const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.dragforce_acceleration(this.__wbg_ptr, epoch_s, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * @returns {number}
+     */
+    get bcFactorM2Kg() {
+        const ret = wasm.dragforce_bcFactorM2Kg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get cutoffAltitudeKm() {
+        const ret = wasm.dragforce_cutoffAltitudeKm(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} cd
+     * @param {number} area_m2
+     * @param {number} mass_kg
+     * @param {SpaceWeather} space_weather
+     * @param {number | null} [cutoff_altitude_km]
+     * @returns {DragForce}
+     */
+    static fromAreaMass(cd, area_m2, mass_kg, space_weather, cutoff_altitude_km) {
+        _assertClass(space_weather, SpaceWeather);
+        const ret = wasm.dragforce_fromAreaMass(cd, area_m2, mass_kg, space_weather.__wbg_ptr, !isLikeNone(cutoff_altitude_km), isLikeNone(cutoff_altitude_km) ? 0 : cutoff_altitude_km);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DragForce.__wrap(ret[0]);
+    }
+    /**
+     * @param {number} bc_kg_m2
+     * @param {SpaceWeather} space_weather
+     * @param {number | null} [cutoff_altitude_km]
+     * @returns {DragForce}
+     */
+    static fromBallisticCoefficient(bc_kg_m2, space_weather, cutoff_altitude_km) {
+        _assertClass(space_weather, SpaceWeather);
+        const ret = wasm.dragforce_fromBallisticCoefficient(bc_kg_m2, space_weather.__wbg_ptr, !isLikeNone(cutoff_altitude_km), isLikeNone(cutoff_altitude_km) ? 0 : cutoff_altitude_km);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DragForce.__wrap(ret[0]);
+    }
+    /**
+     * @param {number} bc_factor_m2_kg
+     * @param {SpaceWeather} space_weather
+     * @param {number | null} [cutoff_altitude_km]
+     * @returns {DragForce}
+     */
+    static fromBcFactor(bc_factor_m2_kg, space_weather, cutoff_altitude_km) {
+        _assertClass(space_weather, SpaceWeather);
+        const ret = wasm.dragforce_fromBcFactor(bc_factor_m2_kg, space_weather.__wbg_ptr, !isLikeNone(cutoff_altitude_km), isLikeNone(cutoff_altitude_km) ? 0 : cutoff_altitude_km);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DragForce.__wrap(ret[0]);
+    }
+    /**
+     * @returns {SpaceWeather}
+     */
+    get spaceWeather() {
+        const ret = wasm.dragforce_spaceWeather(this.__wbg_ptr);
+        return SpaceWeather.__wrap(ret);
+    }
+}
+if (Symbol.dispose) DragForce.prototype[Symbol.dispose] = DragForce.prototype.free;
+exports.DragForce = DragForce;
+
+class DtedTerrain {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DtedTerrainFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dtedterrain_free(ptr, 0);
+    }
+    /**
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @returns {number}
+     */
+    heightM(longitude_deg, latitude_deg) {
+        const ret = wasm.dtedterrain_heightM(this.__wbg_ptr, longitude_deg, latitude_deg);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * @param {number} longitude_deg
+     * @param {number} latitude_deg
+     * @param {any} options
+     * @returns {number}
+     */
+    heightMWithOptions(longitude_deg, latitude_deg, options) {
+        const ret = wasm.dtedterrain_heightMWithOptions(this.__wbg_ptr, longitude_deg, latitude_deg, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * @param {string} root
+     */
+    constructor(root) {
+        const ptr0 = passStringToWasm0(root, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dtedterrain_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        DtedTerrainFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) DtedTerrain.prototype[Symbol.dispose] = DtedTerrain.prototype.free;
+exports.DtedTerrain = DtedTerrain;
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -9225,6 +9521,59 @@ class PppFloatSolution {
 if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolution.prototype.free;
 exports.PppFloatSolution = PppFloatSolution;
 
+/**
+ * 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`].
+ */
+class PreciseEphemerisSampleSource {
+    static __wrap(ptr) {
+        const obj = Object.create(PreciseEphemerisSampleSource.prototype);
+        obj.__wbg_ptr = ptr;
+        PreciseEphemerisSampleSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreciseEphemerisSampleSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_preciseephemerissamplesource_free(ptr, 0);
+    }
+    /**
+     * 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.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerissamplesource_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) PreciseEphemerisSampleSource.prototype[Symbol.dispose] = PreciseEphemerisSampleSource.prototype.free;
+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
@@ -9907,6 +10256,15 @@ class ReducedOrbitState {
 if (Symbol.dispose) ReducedOrbitState.prototype[Symbol.dispose] = ReducedOrbitState.prototype.free;
 exports.ReducedOrbitState = ReducedOrbitState;
 
+/**
+ * @enum {0 | 1}
+ */
+const RetrogradeFactor = Object.freeze({
+    Prograde: 0, "0": "Prograde",
+    Retrograde: 1, "1": "Retrograde",
+});
+exports.RetrogradeFactor = RetrogradeFactor;
+
 /**
  * A parsed RINEX clock product with satellite clock-bias interpolation.
  */
@@ -10450,47 +10808,119 @@ class SatelliteVector {
 if (Symbol.dispose) SatelliteVector.prototype[Symbol.dispose] = SatelliteVector.prototype.free;
 exports.SatelliteVector = SatelliteVector;
 
-/**
- * Per-constellation single-frequency pseudorange code-selection policy. Build
- * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
- * the static `defaultFor(version)`.
- */
-class SignalPolicy {
-    static __wrap(ptr) {
-        const obj = Object.create(SignalPolicy.prototype);
-        obj.__wbg_ptr = ptr;
-        SignalPolicyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+class SbasCorrectionStore {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SignalPolicyFinalization.unregister(this);
+        SbasCorrectionStoreFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signalpolicy_free(ptr, 0);
+        wasm.__wbg_sbascorrectionstore_free(ptr, 0);
     }
     /**
-     * The core default pseudorange policy for a RINEX version.
-     * @param {number} version
-     * @returns {SignalPolicy}
+     * @param {Uint8Array} bytes
+     * @param {string | null | undefined} form
+     * @param {string} geo
+     * @param {number} week
+     * @param {number} tow_s
+     * @param {string | null} [time_scale]
      */
-    static defaultFor(version) {
-        const ret = wasm.signalpolicy_defaultFor(version);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    ingest(bytes, form, geo, week, tow_s, time_scale) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(form) ? 0 : passStringToWasm0(form, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_ingest(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, week, tow_s, ptr3, len3);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        return SignalPolicy.__wrap(ret[0]);
     }
     /**
-     * An empty policy with no constellation preferences.
+     * @param {string} geo
+     * @param {number} receiver_lat_rad
+     * @param {number} receiver_lon_rad
+     * @param {number} receiver_height_m
+     * @param {number} elevation_rad
+     * @param {number} azimuth_rad
+     * @param {number} frequency_hz
+     * @returns {number | undefined}
      */
-    constructor() {
-        const ret = wasm.signalpolicy_new();
-        this.__wbg_ptr = ret;
-        SignalPolicyFinalization.register(this, this.__wbg_ptr, this);
+    ionoSlantDelayM(geo, receiver_lat_rad, receiver_lon_rad, receiver_height_m, elevation_rad, azimuth_rad, frequency_hz) {
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sbascorrectionstore_ionoSlantDelayM(this.__wbg_ptr, ptr0, len0, receiver_lat_rad, receiver_lon_rad, receiver_height_m, elevation_rad, azimuth_rad, frequency_hz);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    constructor() {
+        const ret = wasm.sbascorrectionstore_new();
+        this.__wbg_ptr = ret;
+        SbasCorrectionStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} t_j2000_s
+     * @returns {string[]}
+     */
+    readyGeos(t_j2000_s) {
+        const ret = wasm.sbascorrectionstore_readyGeos(this.__wbg_ptr, t_j2000_s);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) SbasCorrectionStore.prototype[Symbol.dispose] = SbasCorrectionStore.prototype.free;
+exports.SbasCorrectionStore = SbasCorrectionStore;
+
+/**
+ * Per-constellation single-frequency pseudorange code-selection policy. Build
+ * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
+ * the static `defaultFor(version)`.
+ */
+class SignalPolicy {
+    static __wrap(ptr) {
+        const obj = Object.create(SignalPolicy.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalPolicyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalPolicyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signalpolicy_free(ptr, 0);
+    }
+    /**
+     * The core default pseudorange policy for a RINEX version.
+     * @param {number} version
+     * @returns {SignalPolicy}
+     */
+    static defaultFor(version) {
+        const ret = wasm.signalpolicy_defaultFor(version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalPolicy.__wrap(ret[0]);
+    }
+    /**
+     * An empty policy with no constellation preferences.
+     */
+    constructor() {
+        const ret = wasm.signalpolicy_new();
+        this.__wbg_ptr = ret;
+        SignalPolicyFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -10847,6 +11277,25 @@ class Sp3 {
         }
         return Sp3Interpolation.__wrap(ret[0]);
     }
+    /**
+     * 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`.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.sp3_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Satellite tokens present in the product (e.g. `"G01"`), ascending.
      * @returns {string[]}
@@ -10891,6 +11340,21 @@ class Sp3 {
         }
         return SppBatchSolution.__wrap(ret[0]);
     }
+    /**
+     * Run the core robust-reweighted SPP driver under the RAIM/FDE exclusion loop.
+     *
+     * `request` is the FDE request with a `robust` object. The implementation
+     * delegates to `sidereon_core::quality::spp_robust_fde_driver`.
+     * @param {any} request
+     * @returns {FdeSolution}
+     */
+    sppRobustFdeDriver(request) {
+        const ret = wasm.sp3_sppRobustFdeDriver(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return FdeSolution.__wrap(ret[0]);
+    }
     /**
      * The exact parsed state of `satellite` at record `epochIndex` (no
      * interpolation). Throws a `RangeError` past the last epoch and a
@@ -11213,7 +11677,7 @@ class Sp3MergeReport {
     }
     /**
      * Per-(epoch, satellite) agreement statistics for every accepted cell, in
-     * output (epoch, then satellite) order — one entry per cell written to the
+     * output (epoch, then satellite) order, one entry per cell written to the
      * merged product.
      * @returns {Sp3AgreementMetric[]}
      */
@@ -11473,6 +11937,59 @@ class Sp3State {
 if (Symbol.dispose) Sp3State.prototype[Symbol.dispose] = Sp3State.prototype.free;
 exports.Sp3State = Sp3State;
 
+class SpaceWeather {
+    static __wrap(ptr) {
+        const obj = Object.create(SpaceWeather.prototype);
+        obj.__wbg_ptr = ptr;
+        SpaceWeatherFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpaceWeatherFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spaceweather_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get ap() {
+        const ret = wasm.spaceweather_ap(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get f107() {
+        const ret = wasm.spaceweather_f107(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get f107a() {
+        const ret = wasm.spaceweather_f107a(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number | null} [f107]
+     * @param {number | null} [f107a]
+     * @param {number | null} [ap]
+     */
+    constructor(f107, f107a, ap) {
+        const ret = wasm.spaceweather_new(!isLikeNone(f107), isLikeNone(f107) ? 0 : f107, !isLikeNone(f107a), isLikeNone(f107a) ? 0 : f107a, !isLikeNone(ap), isLikeNone(ap) ? 0 : ap);
+        this.__wbg_ptr = ret;
+        SpaceWeatherFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) SpaceWeather.prototype[Symbol.dispose] = SpaceWeather.prototype.free;
+exports.SpaceWeather = SpaceWeather;
+
 /**
  * Canonical quiet-Sun space-weather indices for NRLMSISE-00, mirrored from the
  * core so a JS caller can pass moderate-activity defaults to [`atmosphereDensity`]
@@ -11991,6 +12508,83 @@ class SppSolution {
 if (Symbol.dispose) SppSolution.prototype[Symbol.dispose] = SppSolution.prototype.free;
 exports.SppSolution = SppSolution;
 
+class SsrCorrectionStore {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SsrCorrectionStoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ssrcorrectionstore_free(ptr, 0);
+    }
+    /**
+     * @param {string} sat
+     * @returns {any}
+     */
+    clock(sat) {
+        const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ssrcorrectionstore_clock(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @param {boolean | null | undefined} framed
+     * @param {number} week
+     * @param {number} tow_s
+     * @param {string | null} [time_scale]
+     */
+    ingest(bytes, framed, week, tow_s, time_scale) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(time_scale) ? 0 : passStringToWasm0(time_scale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ssrcorrectionstore_ingest(this.__wbg_ptr, ptr0, len0, isLikeNone(framed) ? 0xFFFFFF : framed ? 1 : 0, week, tow_s, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    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;
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -12922,6 +13516,42 @@ function acquire(samples, prn, options) {
 }
 exports.acquire = acquire;
 
+/**
+ * On-sky angle in degrees between two direction vectors.
+ * @param {Float64Array} a
+ * @param {Float64Array} b
+ * @returns {number}
+ */
+function angularSeparation(a, b) {
+    const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.angularSeparation(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.angularSeparation = angularSeparation;
+
+/**
+ * On-sky angle in degrees between two `(lonDeg, latDeg)` direction pairs.
+ * @param {number} a_lon_deg
+ * @param {number} a_lat_deg
+ * @param {number} b_lon_deg
+ * @param {number} b_lat_deg
+ * @returns {number}
+ */
+function angularSeparationCoords(a_lon_deg, a_lat_deg, b_lon_deg, b_lat_deg) {
+    const ret = wasm.angularSeparationCoords(a_lon_deg, a_lat_deg, b_lon_deg, b_lat_deg);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.angularSeparationCoords = angularSeparationCoords;
+
 /**
  * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
  *
@@ -12963,6 +13593,47 @@ function atmosphereSpaceWeatherDefaults() {
 }
 exports.atmosphereSpaceWeatherDefaults = atmosphereSpaceWeatherDefaults;
 
+/**
+ * Solar beta angle in degrees from orbit normal and Sun vectors.
+ * @param {Float64Array} orbit_normal
+ * @param {Float64Array} sun
+ * @returns {number}
+ */
+function betaAngle(orbit_normal, sun) {
+    const ptr0 = passArrayF64ToWasm0(orbit_normal, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(sun, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.betaAngle(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.betaAngle = betaAngle;
+
+/**
+ * Solar beta angle in degrees from an inertial state and Sun vector.
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {Float64Array} sun
+ * @returns {number}
+ */
+function betaAngleFromState(r, v, sun) {
+    const ptr0 = passArrayF64ToWasm0(r, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(v, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(sun, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.betaAngleFromState(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.betaAngleFromState = betaAngleFromState;
+
 /**
  * Resolve integer ambiguities with a bounded lattice search.
  *
@@ -13102,6 +13773,34 @@ function cn0(eirp_dbw, fspl_db, receiver_gt_dbk, other_losses_db) {
 }
 exports.cn0 = cn0;
 
+/**
+ * @param {any} coe
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+function coe2eq(coe, factor) {
+    const ret = wasm.coe2eq(coe, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.coe2eq = coe2eq;
+
+/**
+ * @param {any} coe
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+function coe2mee(coe, factor) {
+    const ret = wasm.coe2mee(coe, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.coe2mee = coe2mee;
+
 /**
  * Convert classical orbital elements to an inertial Cartesian state.
  *
@@ -13283,6 +13982,37 @@ function coverageLookAngles(satellites, stations, epoch_unix_us) {
 }
 exports.coverageLookAngles = coverageLookAngles;
 
+/**
+ * @param {any} rel
+ * @param {number} n_rad_s
+ * @param {number} dt_s
+ * @returns {any}
+ */
+function cwPropagate(rel, n_rad_s, dt_s) {
+    const ret = wasm.cwPropagate(rel, n_rad_s, dt_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.cwPropagate = cwPropagate;
+
+/**
+ * @param {number} n_rad_s
+ * @param {number} dt_s
+ * @returns {Float64Array}
+ */
+function cwStm(n_rad_s, dt_s) {
+    const ret = wasm.cwStm(n_rad_s, dt_s);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+exports.cwStm = cwStm;
+
 /**
  * Decode Compact RINEX (Hatanaka) bytes into plain RINEX OBS text. Throws a
  * `TypeError` on non-UTF-8 input and an `Error` on a decode failure.
@@ -13395,10 +14125,44 @@ function decodeRtcmMessage(body) {
 exports.decodeRtcmMessage = decodeRtcmMessage;
 
 /**
- * Standard dual-frequency ionosphere-free carrier pair for a constellation.
- * @param {GnssSystem} system
- * @returns {CarrierPair | undefined}
- */
+ * @param {Uint8Array} bytes
+ * @param {string | null} [form]
+ * @returns {any}
+ */
+function decodeSbasMessage(bytes, form) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(form) ? 0 : passStringToWasm0(form, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.decodeSbasMessage(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.decodeSbasMessage = decodeSbasMessage;
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {boolean | null} [framed]
+ * @returns {any}
+ */
+function decodeSsr(bytes, framed) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decodeSsr(ptr0, len0, isLikeNone(framed) ? 0xFFFFFF : framed ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.decodeSsr = decodeSsr;
+
+/**
+ * Standard dual-frequency ionosphere-free carrier pair for a constellation.
+ * @param {GnssSystem} system
+ * @returns {CarrierPair | undefined}
+ */
 function defaultPair(system) {
     const ret = wasm.defaultPair(system);
     return ret === 0 ? undefined : CarrierPair.__wrap(ret);
@@ -13624,6 +14388,34 @@ function earthAngularRadius(satellite_position_km) {
 }
 exports.earthAngularRadius = earthAngularRadius;
 
+/**
+ * @param {number} eccentric_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function eccentricToMean(eccentric_anomaly_rad, eccentricity) {
+    const ret = wasm.eccentricToMean(eccentric_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.eccentricToMean = eccentricToMean;
+
+/**
+ * @param {number} eccentric_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function eccentricToTrue(eccentric_anomaly_rad, eccentricity) {
+    const ret = wasm.eccentricToTrue(eccentric_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.eccentricToTrue = eccentricToTrue;
+
 /**
  * Convert a batch of ITRS (ECEF) positions to geodetic coordinates.
  *
@@ -13876,6 +14668,33 @@ function encounterPlaneCovariance(frame, covariance_km2) {
 }
 exports.encounterPlaneCovariance = encounterPlaneCovariance;
 
+/**
+ * @param {any} eq
+ * @returns {any}
+ */
+function eq2coe(eq) {
+    const ret = wasm.eq2coe(eq);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.eq2coe = eq2coe;
+
+/**
+ * @param {any} eq
+ * @param {number} mu_km3_s2
+ * @returns {any}
+ */
+function eq2rv(eq, mu_km3_s2) {
+    const ret = wasm.eq2rv(eq, mu_km3_s2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.eq2rv = eq2rv;
+
 /**
  * Confidence ellipse from an arbitrary 2x2 covariance block.
  *
@@ -13899,6 +14718,21 @@ function errorEllipse2(covariance, confidence) {
 }
 exports.errorEllipse2 = errorEllipse2;
 
+/**
+ * @param {DragForce} drag
+ * @param {any} request
+ * @returns {any}
+ */
+function estimateDecay(drag, request) {
+    _assertClass(drag, DragForce);
+    const ret = wasm.estimateDecay(drag.__wbg_ptr, request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.estimateDecay = estimateDecay;
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -14262,7 +15096,7 @@ exports.fromCelestrakJson = fromCelestrakJson;
  * skipping (rather than throwing on) entries that do not resolve.
  *
  * The lenient sibling of [`fromCelestrakJson`]: feed it a raw combined CelesTrak
- * `gnss` feed and it returns `{ records, skipped }` — `records` is the `Record[]`
+ * `gnss` feed and it returns `{ records, skipped }`. `records` is the `Record[]`
  * for `system` (the same shape `fromCelestrakJson` returns, sorted by
  * `(system, prn)`), and `skipped` is a `SkippedOmm[]` of the entries whose
  * `OBJECT_NAME` did not resolve to a PRN for `system` (another constellation's
@@ -14610,7 +15444,7 @@ function gnssSp3Id(system, prn) {
 exports.gnssSp3Id = gnssSp3Id;
 
 /**
- * Stable lower-case display label for a constellation, e.g. `"gps"`.
+ * Canonical core display label for a constellation, e.g. `"GPS"`.
  * @param {GnssSystem} system
  * @returns {string}
  */
@@ -15032,7 +15866,7 @@ exports.kurtosis = kurtosis;
  * `covariance` is its `n x n` covariance as a row-major `number[][]`, and
  * `ratioThreshold` is the ratio-test acceptance threshold (RTKLIB's default is
  * `3.0`). Finds the true integer-least-squares optimum and runner-up for any
- * positive-definite covariance — no search box, no combinatorial blow-up.
+ * positive-definite covariance. No search box, no combinatorial blow-up.
  * Returns an `IlsResult`. Throws a `TypeError` on a malformed shape, a
  * `RangeError` on a non-finite or out-of-domain input, and an `Error` on a
  * singular covariance or a non-converging search.
@@ -15316,6 +16150,68 @@ function loadAntex(bytes) {
 }
 exports.loadAntex = loadAntex;
 
+/**
+ * @param {Uint8Array} bytes
+ * @returns {BiasSet}
+ */
+function loadBiasSinex(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loadBiasSinex(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BiasSet.__wrap(ret[0]);
+}
+exports.loadBiasSinex = loadBiasSinex;
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {BiasSet}
+ */
+function loadBiasSinexLossy(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loadBiasSinexLossy(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BiasSet.__wrap(ret[0]);
+}
+exports.loadBiasSinexLossy = loadBiasSinexLossy;
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {BiasSet}
+ */
+function loadCodeDcb(bytes, options) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loadCodeDcb(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BiasSet.__wrap(ret[0]);
+}
+exports.loadCodeDcb = loadCodeDcb;
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {BiasSet}
+ */
+function loadCodeDcbLossy(bytes, options) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loadCodeDcbLossy(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BiasSet.__wrap(ret[0]);
+}
+exports.loadCodeDcbLossy = loadCodeDcbLossy;
+
 /**
  * Alias of [`decodeCrinex`] for callers that read a file as bytes.
  * @param {Uint8Array} bytes
@@ -15441,6 +16337,146 @@ function loadSp3(bytes) {
 }
 exports.loadSp3 = loadSp3;
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function lunarSolarEclipses(start_unix_us, end_unix_us, step_s, tolerance_s) {
+    const ret = wasm.lunarSolarEclipses(start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.lunarSolarEclipses = lunarSolarEclipses;
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function lunarSolarEclipsesSpk(spk, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    _assertClass(spk, Spk);
+    const ret = wasm.lunarSolarEclipsesSpk(spk.__wbg_ptr, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.lunarSolarEclipsesSpk = lunarSolarEclipsesSpk;
+
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function lvlhRotation(position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.lvlhRotation(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+exports.lvlhRotation = lvlhRotation;
+
+/**
+ * @param {number} radius_km
+ * @returns {number}
+ */
+function meanMotionCircular(radius_km) {
+    const ret = wasm.meanMotionCircular(radius_km);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.meanMotionCircular = meanMotionCircular;
+
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {number}
+ */
+function meanMotionFromState(position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.meanMotionFromState(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.meanMotionFromState = meanMotionFromState;
+
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function meanToEccentric(mean_anomaly_rad, eccentricity) {
+    const ret = wasm.meanToEccentric(mean_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.meanToEccentric = meanToEccentric;
+
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function meanToTrue(mean_anomaly_rad, eccentricity) {
+    const ret = wasm.meanToTrue(mean_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.meanToTrue = meanToTrue;
+
+/**
+ * @param {any} mee
+ * @returns {any}
+ */
+function mee2coe(mee) {
+    const ret = wasm.mee2coe(mee);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.mee2coe = mee2coe;
+
+/**
+ * @param {any} mee
+ * @param {number} mu_km3_s2
+ * @returns {any}
+ */
+function mee2rv(mee, mu_km3_s2) {
+    const ret = wasm.mee2rv(mee, mu_km3_s2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.mee2rv = mee2rv;
+
 /**
  * Melbourne-Wubbena combination, metres.
  * @param {number} phi1_cycles
@@ -15503,6 +16539,48 @@ function mergeSp3(sources, options) {
 }
 exports.mergeSp3 = mergeSp3;
 
+/**
+ * @param {string} body
+ * @param {any} station
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function meridianTransits(body, station, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.meridianTransits(ptr0, len0, station, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.meridianTransits = meridianTransits;
+
+/**
+ * @param {Spk} spk
+ * @param {string} body
+ * @param {any} station
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function meridianTransitsSpk(spk, body, station, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    _assertClass(spk, Spk);
+    const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.meridianTransitsSpk(spk.__wbg_ptr, ptr0, len0, station, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.meridianTransitsSpk = meridianTransitsSpk;
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -15609,6 +16687,40 @@ function moonIllumination(latitude_deg, longitude_deg, altitude_km, epoch_unix_u
 }
 exports.moonIllumination = moonIllumination;
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function moonPhases(start_unix_us, end_unix_us, step_s, tolerance_s) {
+    const ret = wasm.moonPhases(start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.moonPhases = moonPhases;
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function moonPhasesSpk(spk, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    _assertClass(spk, Spk);
+    const ret = wasm.moonPhasesSpk(spk.__wbg_ptr, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.moonPhasesSpk = moonPhasesSpk;
+
 /**
  * Narrow-lane code combination, metres.
  * @param {number} p1_m
@@ -15805,6 +16917,67 @@ function observationKindLabel(kind) {
 }
 exports.observationKindLabel = observationKindLabel;
 
+/**
+ * Observe `"sun"` or `"moon"` from a geodetic station at a UTC unix microsecond epoch.
+ * @param {any} station
+ * @param {bigint} epoch_unix_us
+ * @param {string} target
+ * @param {any} options
+ * @returns {any}
+ */
+function observe(station, epoch_unix_us, target, options) {
+    const ptr0 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.observe(station, epoch_unix_us, ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observe = observe;
+
+/**
+ * Observe a caller-supplied SSB-centered target state using an SPK for Earth and Sun.
+ * @param {any} station
+ * @param {bigint} epoch_unix_us
+ * @param {Spk} spk
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @param {any} options
+ * @returns {any}
+ */
+function observeBarycentricState(station, epoch_unix_us, spk, position_km, velocity_km_s, options) {
+    _assertClass(spk, Spk);
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.observeBarycentricState(station, epoch_unix_us, spk.__wbg_ptr, ptr0, len0, ptr1, len1, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observeBarycentricState = observeBarycentricState;
+
+/**
+ * Observe an SPK target body by NAIF id using default full-chain options.
+ * @param {any} station
+ * @param {bigint} epoch_unix_us
+ * @param {Spk} spk
+ * @param {number} naif_id
+ * @returns {any}
+ */
+function observeSpkBody(station, epoch_unix_us, spk, naif_id) {
+    _assertClass(spk, Spk);
+    const ret = wasm.observeSpkBody(station, epoch_unix_us, spk.__wbg_ptr, naif_id);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.observeSpkBody = observeSpkBody;
+
 /**
  * Ocean tide loading displacement of an ITRF station, metres (ECEF).
  *
@@ -16242,6 +17415,47 @@ function phaseMeters(phi_cycles, f_hz) {
 }
 exports.phaseMeters = phaseMeters;
 
+/**
+ * @param {Spk} spk
+ * @param {string} planet
+ * @param {string} kind
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function planetaryEvents(spk, planet, kind, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    _assertClass(spk, Spk);
+    const ptr0 = passStringToWasm0(planet, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.planetaryEvents(spk.__wbg_ptr, ptr0, len0, ptr1, len1, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.planetaryEvents = planetaryEvents;
+
+/**
+ * Position angle in degrees from North through East.
+ * @param {number} from_lon_deg
+ * @param {number} from_lat_deg
+ * @param {number} to_lon_deg
+ * @param {number} to_lat_deg
+ * @returns {number}
+ */
+function positionAngle(from_lon_deg, from_lat_deg, to_lon_deg, to_lat_deg) {
+    const ret = wasm.positionAngle(from_lon_deg, from_lat_deg, to_lon_deg, to_lat_deg);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.positionAngle = positionAngle;
+
 /**
  * Precompute static PPP correction tables for a precise-orbit arc.
  *
@@ -16260,17 +17474,61 @@ exports.phaseMeters = phaseMeters;
  * @param {any} options
  * @returns {any}
  */
-function pppCorrections(sp3, epochs, receiver_ecef_m, options) {
+function pppCorrections(sp3, epochs, receiver_ecef_m, options) {
+    _assertClass(sp3, Sp3);
+    const ptr0 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pppCorrections(sp3.__wbg_ptr, epochs, ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pppCorrections = pppCorrections;
+
+/**
+ * @param {Sp3} sp3
+ * @param {any} epochs
+ * @param {Float64Array} receiver_ecef_m
+ * @param {any} options
+ * @param {BiasSet} bias_set
+ * @param {any} code_bias
+ * @returns {any}
+ */
+function pppCorrectionsWithCodeBias(sp3, epochs, receiver_ecef_m, options, bias_set, code_bias) {
     _assertClass(sp3, Sp3);
     const ptr0 = passArrayF64ToWasm0(receiver_ecef_m, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.pppCorrections(sp3.__wbg_ptr, epochs, ptr0, len0, options);
+    _assertClass(bias_set, BiasSet);
+    const ret = wasm.pppCorrectionsWithCodeBias(sp3.__wbg_ptr, epochs, ptr0, len0, options, bias_set.__wbg_ptr, code_bias);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.pppCorrections = pppCorrections;
+exports.pppCorrectionsWithCodeBias = pppCorrectionsWithCodeBias;
+
+/**
+ * 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`.
+ * @param {any} samples
+ * @returns {PreciseEphemerisSampleSource}
+ */
+function preciseEphemerisSamplesFromSamples(samples) {
+    const ret = wasm.preciseEphemerisSamplesFromSamples(samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PreciseEphemerisSampleSource.__wrap(ret[0]);
+}
+exports.preciseEphemerisSamplesFromSamples = preciseEphemerisSamplesFromSamples;
 
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
@@ -16389,6 +17647,21 @@ function propagateBatch(satellites, epochs_unix_us) {
 }
 exports.propagateBatch = propagateBatch;
 
+/**
+ * @param {any} coe
+ * @param {number} mu_km3_s2
+ * @param {number} dt_s
+ * @returns {any}
+ */
+function propagateKepler(coe, mu_km3_s2, dt_s) {
+    const ret = wasm.propagateKepler(coe, mu_km3_s2, dt_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.propagateKepler = propagateKepler;
+
 /**
  * Numerically propagate an ECI Cartesian state and sample it at a grid of
  * epochs.
@@ -16482,6 +17755,20 @@ function rangeRateToDoppler(range_rate_m_s, carrier_hz) {
 }
 exports.rangeRateToDoppler = rangeRateToDoppler;
 
+/**
+ * @param {any} chief
+ * @param {any} deputy
+ * @returns {any}
+ */
+function relativeState(chief, deputy) {
+    const ret = wasm.relativeState(chief, deputy);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.relativeState = relativeState;
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  * @param {bigint} prn
@@ -16499,6 +17786,26 @@ function replica(prn, options) {
 }
 exports.replica = replica;
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function ricRotation(position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ricRotation(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+exports.ricRotation = ricRotation;
+
 /**
  * RINEX observation band frequency in hertz for a system and band digit.
  * @param {GnssSystem} system
@@ -16535,6 +17842,26 @@ function rinexBandWavelengthM(system, band, glonass_channel) {
 }
 exports.rinexBandWavelengthM = rinexBandWavelengthM;
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function rswRotation(position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.rswRotation(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+exports.rswRotation = rswRotation;
+
 /**
  * Read the 12-bit RTCM message number from a message body.
  *
@@ -16554,6 +17881,26 @@ function rtcmMessageNumber(body) {
 }
 exports.rtcmMessageNumber = rtcmMessageNumber;
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function rtnRotation(position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.rtnRotation(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+exports.rtnRotation = rtnRotation;
+
 /**
  * Transform a 3x3 RTN covariance (flat row-major length 9) to ECI for the given
  * orbit state. Returns a flat row-major length-9 `Float64Array`.
@@ -16606,6 +17953,86 @@ function rv2coe(r, v, mu) {
 }
 exports.rv2coe = rv2coe;
 
+/**
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {number} mu_km3_s2
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+function rv2eq(r, v, mu_km3_s2, factor) {
+    const ptr0 = passArrayF64ToWasm0(r, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(v, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.rv2eq(ptr0, len0, ptr1, len1, mu_km3_s2, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.rv2eq = rv2eq;
+
+/**
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {number} mu_km3_s2
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+function rv2mee(r, v, mu_km3_s2, factor) {
+    const ptr0 = passArrayF64ToWasm0(r, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(v, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.rv2mee(ptr0, len0, ptr1, len1, mu_km3_s2, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.rv2mee = rv2mee;
+
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {string[]} satellites
+ * @param {number} start_j2000_s
+ * @param {number} stop_j2000_s
+ * @param {number} step_s
+ * @returns {any}
+ */
+function sampleBroadcastEphemeris(broadcast, satellites, start_j2000_s, stop_j2000_s, step_s) {
+    _assertClass(broadcast, BroadcastEphemeris);
+    const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sampleBroadcastEphemeris(broadcast.__wbg_ptr, ptr0, len0, start_j2000_s, stop_j2000_s, step_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sampleBroadcastEphemeris = sampleBroadcastEphemeris;
+
+/**
+ * @param {Sp3} sp3
+ * @param {string[]} satellites
+ * @param {number} start_j2000_s
+ * @param {number} stop_j2000_s
+ * @param {number} step_s
+ * @returns {any}
+ */
+function sampleSp3Ephemeris(sp3, satellites, start_j2000_s, stop_j2000_s, step_s) {
+    _assertClass(sp3, Sp3);
+    const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sampleSp3Ephemeris(sp3.__wbg_ptr, ptr0, len0, start_j2000_s, stop_j2000_s, step_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sampleSp3Ephemeris = sampleSp3Ephemeris;
+
 /**
  * Apparent visual magnitude of a sunlit body from a diffuse-sphere phase law.
  *
@@ -16629,6 +18056,32 @@ function satelliteVisualMagnitude(range_km, phase_angle_deg, standard_magnitude,
 }
 exports.satelliteVisualMagnitude = satelliteVisualMagnitude;
 
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {SbasCorrectionStore} store
+ * @param {string} geo
+ * @param {string} sat
+ * @param {number} t_j2000_s
+ * @param {string | null} [mode]
+ * @returns {any}
+ */
+function sbasCorrectedState(broadcast, store, geo, sat, t_j2000_s, mode) {
+    _assertClass(broadcast, BroadcastEphemeris);
+    _assertClass(store, SbasCorrectionStore);
+    const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.sbasCorrectedState(broadcast.__wbg_ptr, store.__wbg_ptr, ptr0, len0, ptr1, len1, t_j2000_s, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sbasCorrectedState = sbasCorrectedState;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -16689,6 +18142,40 @@ function screenTcaConjunctions(primary_line1, primary_line2, secondaries, window
 }
 exports.screenTcaConjunctions = screenTcaConjunctions;
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function seasons(start_unix_us, end_unix_us, step_s, tolerance_s) {
+    const ret = wasm.seasons(start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.seasons = seasons;
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+function seasonsSpk(spk, start_unix_us, end_unix_us, step_s, tolerance_s) {
+    _assertClass(spk, Spk);
+    const ret = wasm.seasonsSpk(spk.__wbg_ptr, start_unix_us, end_unix_us, step_s, tolerance_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.seasonsSpk = seasonsSpk;
+
 /**
  * Select an IONEX product usable at `requestedEpochJ2000S`, degrading to a
  * diurnal-shifted prior product within `policy`.
@@ -16986,6 +18473,20 @@ function solidEarthTide(station_ecef_m, year, month, day, fractional_hour, sun_e
 }
 exports.solidEarthTide = solidEarthTide;
 
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {any}
+ */
+function solveKepler(mean_anomaly_rad, eccentricity) {
+    const ret = wasm.solveKepler(mean_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.solveKepler = solveKepler;
+
 /**
  * Solve a sequence of moving-baseline RTK epochs.
  *
@@ -17164,6 +18665,29 @@ function solveRtkFloat(config) {
 }
 exports.solveRtkFloat = solveRtkFloat;
 
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {SbasCorrectionStore} store
+ * @param {string} geo
+ * @param {any} request
+ * @param {string | null} [mode]
+ * @returns {SppSolution}
+ */
+function solveSppSbas(broadcast, store, geo, request, mode) {
+    _assertClass(broadcast, BroadcastEphemeris);
+    _assertClass(store, SbasCorrectionStore);
+    const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.solveSppSbas(broadcast.__wbg_ptr, store.__wbg_ptr, ptr0, len0, request, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SppSolution.__wrap(ret[0]);
+}
+exports.solveSppSbas = solveSppSbas;
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -17258,6 +18782,30 @@ function solveWithFallback(precise, broadcast, request, policy) {
 }
 exports.solveWithFallback = solveWithFallback;
 
+/**
+ * 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`.
+ * @param {Sp3} sp3
+ * @returns {any}
+ */
+function sp3PreciseEphemerisSamples(sp3) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.sp3PreciseEphemerisSamples(sp3.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sp3PreciseEphemerisSamples = sp3PreciseEphemerisSamples;
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -17270,6 +18818,28 @@ function splitJdToJ2000Seconds(jd_whole, jd_fraction) {
 }
 exports.splitJdToJ2000Seconds = splitJdToJ2000Seconds;
 
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {SsrCorrectionStore} store
+ * @param {string} sat
+ * @param {number} t_j2000_s
+ * @param {boolean | null} [fallback_to_broadcast]
+ * @param {number | null} [allow_regional_provider]
+ * @returns {any}
+ */
+function ssrCorrectedState(broadcast, store, sat, t_j2000_s, fallback_to_broadcast, allow_regional_provider) {
+    _assertClass(broadcast, BroadcastEphemeris);
+    _assertClass(store, SsrCorrectionStore);
+    const ptr0 = passStringToWasm0(sat, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ssrCorrectedState(broadcast.__wbg_ptr, store.__wbg_ptr, ptr0, len0, t_j2000_s, isLikeNone(fallback_to_broadcast) ? 0xFFFFFF : fallback_to_broadcast ? 1 : 0, isLikeNone(allow_regional_provider) ? 0xFFFFFF : allow_regional_provider);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.ssrCorrectedState = ssrCorrectedState;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *
@@ -17644,6 +19214,34 @@ function tropoZenithDelay(lat_deg, height_m, met) {
 }
 exports.tropoZenithDelay = tropoZenithDelay;
 
+/**
+ * @param {number} true_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function trueToEccentric(true_anomaly_rad, eccentricity) {
+    const ret = wasm.trueToEccentric(true_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.trueToEccentric = trueToEccentric;
+
+/**
+ * @param {number} true_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+function trueToMean(true_anomaly_rad, eccentricity) {
+    const ret = wasm.trueToMean(true_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.trueToMean = trueToMean;
+
 /**
  * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
  * @returns {Ut1Coverage}
@@ -18247,6 +19845,9 @@ const AppliedCorrectionsFinalization = (typeof FinalizationRegistry === 'undefin
 const AtmosphereDensityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_atmospheredensity_free(ptr, 1));
+const BiasSetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_biasset_free(ptr, 1));
 const BroadcastEphemerisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_broadcastephemeris_free(ptr, 1));
@@ -18316,6 +19917,12 @@ const DopSeriesSampleFinalization = (typeof FinalizationRegistry === 'undefined'
 const DopplerShiftFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dopplershift_free(ptr, 1));
+const DragForceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dragforce_free(ptr, 1));
+const DtedTerrainFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dtedterrain_free(ptr, 1));
 const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_encounterframe_free(ptr, 1));
@@ -18511,6 +20118,9 @@ const PppFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined
 const PppFloatSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pppfloatsolution_free(ptr, 1));
+const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));
 const PredictBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_predictbatch_free(ptr, 1));
@@ -18553,6 +20163,9 @@ const SatellitePassFinalization = (typeof FinalizationRegistry === 'undefined')
 const SatelliteVectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_satellitevector_free(ptr, 1));
+const SbasCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbascorrectionstore_free(ptr, 1));
 const SignalPolicyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalpolicy_free(ptr, 1));
@@ -18592,6 +20205,9 @@ const Sp3SelectionFinalization = (typeof FinalizationRegistry === 'undefined')
 const Sp3StateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sp3state_free(ptr, 1));
+const SpaceWeatherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spaceweather_free(ptr, 1));
 const SpaceWeatherDefaultsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spaceweatherdefaults_free(ptr, 1));
@@ -18610,6 +20226,9 @@ const SppBatchSolutionFinalization = (typeof FinalizationRegistry === 'undefined
 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 SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sunmoon_free(ptr, 1));