@neilberkman/sidereon 0.9.1 → 0.10.0

package/pkg/sidereon.js

@@ -587,6 +587,145 @@ export class AtmosphereDensity {
 }
 if (Symbol.dispose) AtmosphereDensity.prototype[Symbol.dispose] = AtmosphereDensity.prototype.free;
 
+export 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;
+
 /**
  * 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.
@@ -3122,6 +3261,160 @@ export class DopplerShift {
 }
 if (Symbol.dispose) DopplerShift.prototype[Symbol.dispose] = DopplerShift.prototype.free;
 
+export 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;
+
+export 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;
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -9126,6 +9419,58 @@ export class PppFloatSolution {
 }
 if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolution.prototype.free;
 
+/**
+ * A precise-ephemeris source built from samples rather than parsed SP3 text.
+ *
+ * Implements the same `ObservableEphemerisSource` contract as a parsed [`Sp3`]
+ * product and shares its interpolation substrate, so [`predictRanges`] accepts
+ * either handle. Build one with [`preciseEphemerisSamplesFromSamples`].
+ */
+export class PreciseEphemerisSampleSource {
+    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;
+
 /**
  * The per-request results of a batch observable prediction, index-aligned to
  * the input requests. Each request independently either produced observables or
@@ -9799,6 +10144,14 @@ export class ReducedOrbitState {
 }
 if (Symbol.dispose) ReducedOrbitState.prototype[Symbol.dispose] = ReducedOrbitState.prototype.free;
 
+/**
+ * @enum {0 | 1}
+ */
+export const RetrogradeFactor = Object.freeze({
+    Prograde: 0, "0": "Prograde",
+    Retrograde: 1, "1": "Retrograde",
+});
+
 /**
  * A parsed RINEX clock product with satellite clock-bias interpolation.
  */
@@ -10336,47 +10689,118 @@ export class SatelliteVector {
 }
 if (Symbol.dispose) SatelliteVector.prototype[Symbol.dispose] = SatelliteVector.prototype.free;
 
-/**
- * Per-constellation single-frequency pseudorange code-selection policy. Build
- * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
- * the static `defaultFor(version)`.
- */
-export class SignalPolicy {
-    static __wrap(ptr) {
-        const obj = Object.create(SignalPolicy.prototype);
-        obj.__wbg_ptr = ptr;
-        SignalPolicyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export 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;
+
+/**
+ * Per-constellation single-frequency pseudorange code-selection policy. Build
+ * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
+ * the static `defaultFor(version)`.
+ */
+export 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;
     }
     /**
@@ -10728,6 +11152,25 @@ export 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[]}
@@ -10772,6 +11215,21 @@ export 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
@@ -11089,7 +11547,7 @@ export 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[]}
      */
@@ -11345,6 +11803,58 @@ export class Sp3State {
 }
 if (Symbol.dispose) Sp3State.prototype[Symbol.dispose] = Sp3State.prototype.free;
 
+export 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;
+
 /**
  * Canonical quiet-Sun space-weather indices for NRLMSISE-00, mirrored from the
  * core so a JS caller can pass moderate-activity defaults to [`atmosphereDensity`]
@@ -11857,6 +12367,82 @@ export class SppSolution {
 }
 if (Symbol.dispose) SppSolution.prototype[Symbol.dispose] = SppSolution.prototype.free;
 
+export 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;
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -12777,6 +13363,40 @@ export function acquire(samples, prn, options) {
     return AcquisitionResult.__wrap(ret[0]);
 }
 
+/**
+ * On-sky angle in degrees between two direction vectors.
+ * @param {Float64Array} a
+ * @param {Float64Array} b
+ * @returns {number}
+ */
+export 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];
+}
+
+/**
+ * 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}
+ */
+export 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];
+}
+
 /**
  * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
  *
@@ -12816,6 +13436,45 @@ export function atmosphereSpaceWeatherDefaults() {
     return SpaceWeatherDefaults.__wrap(ret);
 }
 
+/**
+ * Solar beta angle in degrees from orbit normal and Sun vectors.
+ * @param {Float64Array} orbit_normal
+ * @param {Float64Array} sun
+ * @returns {number}
+ */
+export 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];
+}
+
+/**
+ * Solar beta angle in degrees from an inertial state and Sun vector.
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {Float64Array} sun
+ * @returns {number}
+ */
+export 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];
+}
+
 /**
  * Resolve integer ambiguities with a bounded lattice search.
  *
@@ -12947,6 +13606,32 @@ export function cn0(eirp_dbw, fspl_db, receiver_gt_dbk, other_losses_db) {
     return ret[0];
 }
 
+/**
+ * @param {any} coe
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+export function coe2eq(coe, factor) {
+    const ret = wasm.coe2eq(coe, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} coe
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+export function coe2mee(coe, factor) {
+    const ret = wasm.coe2mee(coe, isLikeNone(factor) ? 2 : factor);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Convert classical orbital elements to an inertial Cartesian state.
  *
@@ -13119,6 +13804,35 @@ export function coverageLookAngles(satellites, stations, epoch_unix_us) {
     return CoverageGrid.__wrap(ret[0]);
 }
 
+/**
+ * @param {any} rel
+ * @param {number} n_rad_s
+ * @param {number} dt_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {number} n_rad_s
+ * @param {number} dt_s
+ * @returns {Float64Array}
+ */
+export 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;
+}
+
 /**
  * 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.
@@ -13226,10 +13940,42 @@ export function decodeRtcmMessage(body) {
 }
 
 /**
- * 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}
+ */
+export 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]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {boolean | null} [framed]
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * Standard dual-frequency ionosphere-free carrier pair for a constellation.
+ * @param {GnssSystem} system
+ * @returns {CarrierPair | undefined}
+ */
 export function defaultPair(system) {
     const ret = wasm.defaultPair(system);
     return ret === 0 ? undefined : CarrierPair.__wrap(ret);
@@ -13444,6 +14190,32 @@ export function earthAngularRadius(satellite_position_km) {
     return v2;
 }
 
+/**
+ * @param {number} eccentric_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function eccentricToMean(eccentric_anomaly_rad, eccentricity) {
+    const ret = wasm.eccentricToMean(eccentric_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * @param {number} eccentric_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function eccentricToTrue(eccentric_anomaly_rad, eccentricity) {
+    const ret = wasm.eccentricToTrue(eccentric_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Convert a batch of ITRS (ECEF) positions to geodetic coordinates.
  *
@@ -13684,6 +14456,31 @@ export function encounterPlaneCovariance(frame, covariance_km2) {
     return v2;
 }
 
+/**
+ * @param {any} eq
+ * @returns {any}
+ */
+export function eq2coe(eq) {
+    const ret = wasm.eq2coe(eq);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} eq
+ * @param {number} mu_km3_s2
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Confidence ellipse from an arbitrary 2x2 covariance block.
  *
@@ -13706,6 +14503,20 @@ export function errorEllipse2(covariance, confidence) {
     return ErrorEllipse2.__wrap(ret[0]);
 }
 
+/**
+ * @param {DragForce} drag
+ * @param {any} request
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
  * window.
@@ -14055,7 +14866,7 @@ export function fromCelestrakJson(json, system) {
  * 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
@@ -14387,7 +15198,7 @@ export function gnssSp3Id(system, prn) {
 }
 
 /**
- * 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}
  */
@@ -14790,7 +15601,7 @@ export function kurtosis(x, fisher, bias) {
  * `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.
@@ -15060,6 +15871,64 @@ export function loadAntex(bytes) {
     return Antex.__wrap(ret[0]);
 }
 
+/**
+ * @param {Uint8Array} bytes
+ * @returns {BiasSet}
+ */
+export 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]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {BiasSet}
+ */
+export 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]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {BiasSet}
+ */
+export 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]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {any} options
+ * @returns {BiasSet}
+ */
+export 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]);
+}
+
 /**
  * Alias of [`decodeCrinex`] for callers that read a file as bytes.
  * @param {Uint8Array} bytes
@@ -15178,6 +16047,137 @@ export function loadSp3(bytes) {
     return Sp3.__wrap(ret[0]);
 }
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+export 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;
+}
+
+/**
+ * @param {number} radius_km
+ * @returns {number}
+ */
+export function meanMotionCircular(radius_km) {
+    const ret = wasm.meanMotionCircular(radius_km);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {number}
+ */
+export 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];
+}
+
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function meanToEccentric(mean_anomaly_rad, eccentricity) {
+    const ret = wasm.meanToEccentric(mean_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function meanToTrue(mean_anomaly_rad, eccentricity) {
+    const ret = wasm.meanToTrue(mean_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * @param {any} mee
+ * @returns {any}
+ */
+export function mee2coe(mee) {
+    const ret = wasm.mee2coe(mee);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} mee
+ * @param {number} mu_km3_s2
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Melbourne-Wubbena combination, metres.
  * @param {number} phi1_cycles
@@ -15237,6 +16237,46 @@ export function mergeSp3(sources, options) {
     return Sp3MergeResult.__wrap(ret[0]);
 }
 
+/**
+ * @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}
+ */
+export 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]);
+}
+
+/**
+ * @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}
+ */
+export 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]);
+}
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -15338,6 +16378,38 @@ export function moonIllumination(latitude_deg, longitude_deg, altitude_km, epoch
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Narrow-lane code combination, metres.
  * @param {number} p1_m
@@ -15525,6 +16597,64 @@ export function observationKindLabel(kind) {
     }
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
+/**
+ * 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}
+ */
+export 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]);
+}
+
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * Ocean tide loading displacement of an ITRF station, metres (ECEF).
  *
@@ -15938,6 +17068,45 @@ export function phaseMeters(phi_cycles, f_hz) {
     return ret[0];
 }
 
+/**
+ * @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}
+ */
+export 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]);
+}
+
+/**
+ * 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}
+ */
+export 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];
+}
+
 /**
  * Precompute static PPP correction tables for a precise-orbit arc.
  *
@@ -15956,17 +17125,59 @@ export function phaseMeters(phi_cycles, f_hz) {
  * @param {any} options
  * @returns {any}
  */
-export function pppCorrections(sp3, epochs, receiver_ecef_m, options) {
+export 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]);
+}
+
+/**
+ * @param {Sp3} sp3
+ * @param {any} epochs
+ * @param {Float64Array} receiver_ecef_m
+ * @param {any} options
+ * @param {BiasSet} bias_set
+ * @param {any} code_bias
+ * @returns {any}
+ */
+export 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]);
 }
 
+/**
+ * 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}
+ */
+export function preciseEphemerisSamplesFromSamples(samples) {
+    const ret = wasm.preciseEphemerisSamplesFromSamples(samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PreciseEphemerisSampleSource.__wrap(ret[0]);
+}
+
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
  * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
@@ -16080,6 +17291,20 @@ export function propagateBatch(satellites, epochs_unix_us) {
     return FleetPropagation.__wrap(ret[0]);
 }
 
+/**
+ * @param {any} coe
+ * @param {number} mu_km3_s2
+ * @param {number} dt_s
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Numerically propagate an ECI Cartesian state and sample it at a grid of
  * epochs.
@@ -16168,6 +17393,19 @@ export function rangeRateToDoppler(range_rate_m_s, carrier_hz) {
     return ret[0];
 }
 
+/**
+ * @param {any} chief
+ * @param {any} deputy
+ * @returns {any}
+ */
+export function relativeState(chief, deputy) {
+    const ret = wasm.relativeState(chief, deputy);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  * @param {bigint} prn
@@ -16184,6 +17422,25 @@ export function replica(prn, options) {
     return v1;
 }
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+export 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;
+}
+
 /**
  * RINEX observation band frequency in hertz for a system and band digit.
  * @param {GnssSystem} system
@@ -16218,6 +17475,25 @@ export function rinexBandWavelengthM(system, band, glonass_channel) {
     return ret[0] === 0 ? undefined : ret[1];
 }
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+export 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;
+}
+
 /**
  * Read the 12-bit RTCM message number from a message body.
  *
@@ -16236,6 +17512,25 @@ export function rtcmMessageNumber(body) {
     return ret[0];
 }
 
+/**
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+export 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;
+}
+
 /**
  * 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`.
@@ -16286,6 +17581,82 @@ export function rv2coe(r, v, mu) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {number} mu_km3_s2
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Float64Array} r
+ * @param {Float64Array} v
+ * @param {number} mu_km3_s2
+ * @param {RetrogradeFactor | null} [factor]
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {string[]} satellites
+ * @param {number} start_j2000_s
+ * @param {number} stop_j2000_s
+ * @param {number} step_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Sp3} sp3
+ * @param {string[]} satellites
+ * @param {number} start_j2000_s
+ * @param {number} stop_j2000_s
+ * @param {number} step_s
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Apparent visual magnitude of a sunlit body from a diffuse-sphere phase law.
  *
@@ -16308,6 +17679,31 @@ export function satelliteVisualMagnitude(range_km, phase_angle_deg, standard_mag
     return ret[0];
 }
 
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {SbasCorrectionStore} store
+ * @param {string} geo
+ * @param {string} sat
+ * @param {number} t_j2000_s
+ * @param {string | null} [mode]
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -16366,6 +17762,38 @@ export function screenTcaConjunctions(primary_line1, primary_line2, secondaries,
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
+/**
+ * @param {Spk} spk
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_s
+ * @param {number} tolerance_s
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Select an IONEX product usable at `requestedEpochJ2000S`, degrading to a
  * diurnal-shifted prior product within `policy`.
@@ -16649,6 +18077,19 @@ export function solidEarthTide(station_ecef_m, year, month, day, fractional_hour
     return v4;
 }
 
+/**
+ * @param {number} mean_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {any}
+ */
+export 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]);
+}
+
 /**
  * Solve a sequence of moving-baseline RTK epochs.
  *
@@ -16819,6 +18260,28 @@ export function solveRtkFloat(config) {
     return RtkFloatSolution.__wrap(ret[0]);
 }
 
+/**
+ * @param {BroadcastEphemeris} broadcast
+ * @param {SbasCorrectionStore} store
+ * @param {string} geo
+ * @param {any} request
+ * @param {string | null} [mode]
+ * @returns {SppSolution}
+ */
+export 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]);
+}
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -16909,6 +18372,29 @@ export function solveWithFallback(precise, broadcast, request, policy) {
     return SourcedSolution.__wrap(ret[0]);
 }
 
+/**
+ * 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}
+ */
+export function sp3PreciseEphemerisSamples(sp3) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.sp3PreciseEphemerisSamples(sp3.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -16920,6 +18406,27 @@ export function splitJdToJ2000Seconds(jd_whole, jd_fraction) {
     return ret;
 }
 
+/**
+ * @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}
+ */
+export 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]);
+}
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *
@@ -17277,6 +18784,32 @@ export function tropoZenithDelay(lat_deg, height_m, met) {
     return ZenithDelay.__wrap(ret[0]);
 }
 
+/**
+ * @param {number} true_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function trueToEccentric(true_anomaly_rad, eccentricity) {
+    const ret = wasm.trueToEccentric(true_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * @param {number} true_anomaly_rad
+ * @param {number} eccentricity
+ * @returns {number}
+ */
+export function trueToMean(true_anomaly_rad, eccentricity) {
+    const ret = wasm.trueToMean(true_anomaly_rad, eccentricity);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
  * @returns {Ut1Coverage}
@@ -17871,6 +19404,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));
@@ -17940,6 +19476,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));
@@ -18135,6 +19677,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));
@@ -18177,6 +19722,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));
@@ -18216,6 +19764,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));
@@ -18234,6 +19785,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));