@neilberkman/sidereon 0.18.0 → 0.19.0

package/pkg-node/sidereon.d.ts

@@ -6070,6 +6070,14 @@ export class SmoothCodeResult {
     readonly window: number;
 }
 
+export class SmoothedTrack {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly epochCount: number;
+    readonly epochs: any;
+}
+
 /**
  * A receiver solution paired with the provenance of the ephemeris that produced
  * it. Returned by [`solveWithFallback`].
@@ -7573,6 +7581,71 @@ export class TlePropagation {
     readonly velocityKmS: Float64Array;
 }
 
+export class TrackFilter {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a filter from a position fix and uncertain zero initial velocity.
+     */
+    static fromPosition(config: any): TrackFilter;
+    /**
+     * Build a stateful no-IMU track filter from a `TrackFilterConfig`.
+     */
+    constructor(config: TrackFilterConfig);
+    positionInnovation(request: any): any;
+    predict(dt_s: number): any;
+    predictRecorded(dt_s: number, history: TrackRtsHistoryBuilder): any;
+    recordPredictionOnly(history: TrackRtsHistoryBuilder): void;
+    stateInnovation(request: any): any;
+    updatePosition(request: any): any;
+    updatePositionGated(request: any): any;
+    updatePositionGatedRecorded(request: any, history: TrackRtsHistoryBuilder): any;
+    updatePositionRecorded(request: any, history: TrackRtsHistoryBuilder): any;
+    updateState(request: any): any;
+    readonly accelerationVarianceSpectralDensityM2S3: number;
+    readonly dimension: number;
+    readonly state: any;
+}
+
+export class TrackFilterConfig {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a config from a position fix and uncertain zero initial velocity.
+     */
+    static fromPosition(config: any): TrackFilterConfig;
+    /**
+     * Build a no-IMU track filter config from a JS object.
+     */
+    constructor(config: any);
+    toObject(): any;
+    readonly dimension: number;
+    readonly frame: string;
+    readonly initialTS: number;
+}
+
+export class TrackRtsHistory {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly epochCount: number;
+    readonly epochs: any;
+}
+
+export class TrackRtsHistoryBuilder {
+    free(): void;
+    [Symbol.dispose](): void;
+    finish(): TrackRtsHistory;
+    /**
+     * Start a history from the filter's current state.
+     */
+    static fromFilter(filter: TrackFilter): TrackRtsHistoryBuilder;
+    /**
+     * Start an empty history for manual recording.
+     */
+    constructor();
+}
+
 /**
  * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
  */
@@ -10235,6 +10308,8 @@ export function smoothCode(arc: any, options: any, hatch_window_cap?: number | n
  */
 export function smoothIonoFreeCode(arc: any, options: any, hatch_window_cap?: number | null): IonoFreeSmoothResult[];
 
+export function smoothTrackRts(history: TrackRtsHistory): SmoothedTrack;
+
 /**
  * Post-correlation predetection SNR in decibels.
  */

package/pkg-node/sidereon.js

@@ -15490,6 +15490,44 @@ class SmoothCodeResult {
 if (Symbol.dispose) SmoothCodeResult.prototype[Symbol.dispose] = SmoothCodeResult.prototype.free;
 exports.SmoothCodeResult = SmoothCodeResult;
 
+class SmoothedTrack {
+    static __wrap(ptr) {
+        const obj = Object.create(SmoothedTrack.prototype);
+        obj.__wbg_ptr = ptr;
+        SmoothedTrackFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SmoothedTrackFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_smoothedtrack_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.smoothedtrack_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.smoothedtrack_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) SmoothedTrack.prototype[Symbol.dispose] = SmoothedTrack.prototype.free;
+exports.SmoothedTrack = SmoothedTrack;
+
 /**
  * A receiver solution paired with the provenance of the ephemeris that produced
  * it. Returned by [`solveWithFallback`].
@@ -19237,6 +19275,368 @@ class TlePropagation {
 if (Symbol.dispose) TlePropagation.prototype[Symbol.dispose] = TlePropagation.prototype.free;
 exports.TlePropagation = TlePropagation;
 
+class TrackFilter {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackFilter.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackFilterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackFilterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackfilter_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get accelerationVarianceSpectralDensityM2S3() {
+        const ret = wasm.trackfilter_accelerationVarianceSpectralDensityM2S3(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get dimension() {
+        const ret = wasm.trackfilter_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Build a filter from a position fix and uncertain zero initial velocity.
+     * @param {any} config
+     * @returns {TrackFilter}
+     */
+    static fromPosition(config) {
+        const ret = wasm.trackfilter_fromPosition(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackFilter.__wrap(ret[0]);
+    }
+    /**
+     * Build a stateful no-IMU track filter from a `TrackFilterConfig`.
+     * @param {TrackFilterConfig} config
+     */
+    constructor(config) {
+        _assertClass(config, TrackFilterConfig);
+        const ret = wasm.trackfilter_new(config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        TrackFilterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    positionInnovation(request) {
+        const ret = wasm.trackfilter_positionInnovation(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} dt_s
+     * @returns {any}
+     */
+    predict(dt_s) {
+        const ret = wasm.trackfilter_predict(this.__wbg_ptr, dt_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} dt_s
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    predictRecorded(dt_s, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_predictRecorded(this.__wbg_ptr, dt_s, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {TrackRtsHistoryBuilder} history
+     */
+    recordPredictionOnly(history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_recordPredictionOnly(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    get state() {
+        const ret = wasm.trackfilter_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    stateInnovation(request) {
+        const ret = wasm.trackfilter_stateInnovation(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updatePosition(request) {
+        const ret = wasm.trackfilter_updatePosition(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updatePositionGated(request) {
+        const ret = wasm.trackfilter_updatePositionGated(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updatePositionGatedRecorded(request, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_updatePositionGatedRecorded(this.__wbg_ptr, request, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @param {TrackRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updatePositionRecorded(request, history) {
+        _assertClass(history, TrackRtsHistoryBuilder);
+        const ret = wasm.trackfilter_updatePositionRecorded(this.__wbg_ptr, request, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    updateState(request) {
+        const ret = wasm.trackfilter_updateState(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) TrackFilter.prototype[Symbol.dispose] = TrackFilter.prototype.free;
+exports.TrackFilter = TrackFilter;
+
+class TrackFilterConfig {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackFilterConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackFilterConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackFilterConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackfilterconfig_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get dimension() {
+        const ret = wasm.trackfilterconfig_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get frame() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.trackfilterconfig_frame(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Build a config from a position fix and uncertain zero initial velocity.
+     * @param {any} config
+     * @returns {TrackFilterConfig}
+     */
+    static fromPosition(config) {
+        const ret = wasm.trackfilterconfig_fromPosition(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackFilterConfig.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get initialTS() {
+        const ret = wasm.trackfilterconfig_initialTS(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Build a no-IMU track filter config from a JS object.
+     * @param {any} config
+     */
+    constructor(config) {
+        const ret = wasm.trackfilterconfig_new(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        TrackFilterConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {any}
+     */
+    toObject() {
+        const ret = wasm.trackfilterconfig_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) TrackFilterConfig.prototype[Symbol.dispose] = TrackFilterConfig.prototype.free;
+exports.TrackFilterConfig = TrackFilterConfig;
+
+class TrackRtsHistory {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackRtsHistory.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackRtsHistoryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackRtsHistoryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackrtshistory_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.trackrtshistory_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.trackrtshistory_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) TrackRtsHistory.prototype[Symbol.dispose] = TrackRtsHistory.prototype.free;
+exports.TrackRtsHistory = TrackRtsHistory;
+
+class TrackRtsHistoryBuilder {
+    static __wrap(ptr) {
+        const obj = Object.create(TrackRtsHistoryBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        TrackRtsHistoryBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrackRtsHistoryBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trackrtshistorybuilder_free(ptr, 0);
+    }
+    /**
+     * @returns {TrackRtsHistory}
+     */
+    finish() {
+        const ret = wasm.trackrtshistorybuilder_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackRtsHistory.__wrap(ret[0]);
+    }
+    /**
+     * Start a history from the filter's current state.
+     * @param {TrackFilter} filter
+     * @returns {TrackRtsHistoryBuilder}
+     */
+    static fromFilter(filter) {
+        _assertClass(filter, TrackFilter);
+        const ret = wasm.trackrtshistorybuilder_fromFilter(filter.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TrackRtsHistoryBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Start an empty history for manual recording.
+     */
+    constructor() {
+        const ret = wasm.trackrtshistorybuilder_new();
+        this.__wbg_ptr = ret;
+        TrackRtsHistoryBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) TrackRtsHistoryBuilder.prototype[Symbol.dispose] = TrackRtsHistoryBuilder.prototype.free;
+exports.TrackRtsHistoryBuilder = TrackRtsHistoryBuilder;
+
 /**
  * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
  */
@@ -26694,6 +27094,20 @@ function smoothIonoFreeCode(arc, options, hatch_window_cap) {
 }
 exports.smoothIonoFreeCode = smoothIonoFreeCode;
 
+/**
+ * @param {TrackRtsHistory} history
+ * @returns {SmoothedTrack}
+ */
+function smoothTrackRts(history) {
+    _assertClass(history, TrackRtsHistory);
+    const ret = wasm.smoothTrackRts(history.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SmoothedTrack.__wrap(ret[0]);
+}
+exports.smoothTrackRts = smoothTrackRts;
+
 /**
  * Post-correlation predetection SNR in decibels.
  * @param {number} cn0_dbhz
@@ -28910,6 +29324,9 @@ const SlipResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const SmoothCodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smoothcoderesult_free(ptr, 1));
+const SmoothedTrackFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_smoothedtrack_free(ptr, 1));
 const SourcedSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sourcedsolution_free(ptr, 1));
@@ -29018,6 +29435,18 @@ const TleFitFinalization = (typeof FinalizationRegistry === 'undefined')
 const TlePropagationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tlepropagation_free(ptr, 1));
+const TrackFilterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackfilter_free(ptr, 1));
+const TrackFilterConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackfilterconfig_free(ptr, 1));
+const TrackRtsHistoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackrtshistory_free(ptr, 1));
+const TrackRtsHistoryBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trackrtshistorybuilder_free(ptr, 1));
 const Ut1CoverageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ut1coverage_free(ptr, 1));