@neilberkman/sidereon 0.19.0 → 0.19.1

package/pkg-node/sidereon.d.ts

@@ -2042,6 +2042,43 @@ export class FrameStates {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * Recorded fusion forward-pass history accepted by `smoothFusionRts`.
+ */
+export class FusionRtsHistory {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of recorded epochs.
+     */
+    readonly epochCount: number;
+    /**
+     * Recorded epochs in forward time order.
+     */
+    readonly epochs: any;
+}
+
+/**
+ * Builder for recording a fusion forward pass before RTS smoothing.
+ */
+export class FusionRtsHistoryBuilder {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Return a validated recorded history.
+     */
+    finish(): FusionRtsHistory;
+    /**
+     * Start a history from the filter's current checkpoint.
+     */
+    static fromFilter(filter: GnssInsFilter): FusionRtsHistoryBuilder;
+    /**
+     * Start an empty history for manual recording.
+     */
+    constructor();
+}
+
 /**
  * WGS84 geodesic input failure class exposed as a stable enum symbol.
  */
@@ -2351,6 +2388,10 @@ export class GnssInsFilter {
      * Propagate the filter with a JS array of IMU samples.
      */
     propagateBatch(samples: any): any;
+    /**
+     * Propagate and record the transition for later fusion RTS smoothing.
+     */
+    propagateRecorded(sample: any, history: FusionRtsHistoryBuilder): any;
     /**
      * Restore this filter from versioned fusion-state bytes.
      */
@@ -2371,6 +2412,10 @@ export class GnssInsFilter {
      * Apply a loose position or position-velocity GNSS fix at the current epoch.
      */
     updateLoose(measurement: any): any;
+    /**
+     * Apply a loose GNSS fix and record checkpoints for fusion RTS smoothing.
+     */
+    updateLooseRecorded(measurement: any, history: FusionRtsHistoryBuilder): any;
     /**
      * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
      */
@@ -2379,6 +2424,10 @@ export class GnssInsFilter {
      * Apply a tight raw-observation epoch against a broadcast ephemeris source.
      */
     updateTightBroadcast(broadcast: BroadcastEphemeris, epoch: any): any;
+    /**
+     * Apply a tight broadcast update and record checkpoints for fusion RTS smoothing.
+     */
+    updateTightBroadcastRecorded(broadcast: BroadcastEphemeris, epoch: any, history: FusionRtsHistoryBuilder): any;
     /**
      * Apply a tight broadcast update, replaying retained IMU checkpoints when it is late.
      */
@@ -2387,6 +2436,10 @@ export class GnssInsFilter {
      * Apply a tight raw-observation epoch against an SP3 source.
      */
     updateTightSp3(sp3: Sp3, epoch: any): any;
+    /**
+     * Apply a tight SP3 update and record checkpoints for fusion RTS smoothing.
+     */
+    updateTightSp3Recorded(sp3: Sp3, epoch: any, history: FusionRtsHistoryBuilder): any;
     /**
      * Apply a tight SP3 update, replaying retained IMU checkpoints when it is late.
      */
@@ -6070,6 +6123,23 @@ export class SmoothCodeResult {
     readonly window: number;
 }
 
+/**
+ * Smoothed fusion trajectory returned by fixed-interval RTS smoothing.
+ */
+export class SmoothedFusionTrajectory {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of smoothed epochs.
+     */
+    readonly epochCount: number;
+    /**
+     * Smoothed epochs in the same order as the recorded history.
+     */
+    readonly epochs: any;
+}
+
 export class SmoothedTrack {
     private constructor();
     free(): void;
@@ -10303,6 +10373,11 @@ export function slipReasonLabel(reason: SlipReason): string;
  */
 export function smoothCode(arc: any, options: any, hatch_window_cap?: number | null): SmoothCodeResult[];
 
+/**
+ * Apply fixed-interval RTS smoothing to recorded fusion history.
+ */
+export function smoothFusionRts(history: FusionRtsHistory): SmoothedFusionTrajectory;
+
 /**
  * Dual-frequency ionosphere-free Hatch carrier-smoothed code.
  */

package/pkg-node/sidereon.js

@@ -5103,6 +5103,106 @@ class FrameStates {
 if (Symbol.dispose) FrameStates.prototype[Symbol.dispose] = FrameStates.prototype.free;
 exports.FrameStates = FrameStates;
 
+/**
+ * Recorded fusion forward-pass history accepted by `smoothFusionRts`.
+ */
+class FusionRtsHistory {
+    static __wrap(ptr) {
+        const obj = Object.create(FusionRtsHistory.prototype);
+        obj.__wbg_ptr = ptr;
+        FusionRtsHistoryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FusionRtsHistoryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fusionrtshistory_free(ptr, 0);
+    }
+    /**
+     * Number of recorded epochs.
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.fusionrtshistory_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Recorded epochs in forward time order.
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.fusionrtshistory_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) FusionRtsHistory.prototype[Symbol.dispose] = FusionRtsHistory.prototype.free;
+exports.FusionRtsHistory = FusionRtsHistory;
+
+/**
+ * Builder for recording a fusion forward pass before RTS smoothing.
+ */
+class FusionRtsHistoryBuilder {
+    static __wrap(ptr) {
+        const obj = Object.create(FusionRtsHistoryBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        FusionRtsHistoryBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FusionRtsHistoryBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fusionrtshistorybuilder_free(ptr, 0);
+    }
+    /**
+     * Return a validated recorded history.
+     * @returns {FusionRtsHistory}
+     */
+    finish() {
+        const ret = wasm.fusionrtshistorybuilder_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return FusionRtsHistory.__wrap(ret[0]);
+    }
+    /**
+     * Start a history from the filter's current checkpoint.
+     * @param {GnssInsFilter} filter
+     * @returns {FusionRtsHistoryBuilder}
+     */
+    static fromFilter(filter) {
+        _assertClass(filter, GnssInsFilter);
+        const ret = wasm.fusionrtshistorybuilder_fromFilter(filter.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return FusionRtsHistoryBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Start an empty history for manual recording.
+     */
+    constructor() {
+        const ret = wasm.fusionrtshistorybuilder_new();
+        this.__wbg_ptr = ret;
+        FusionRtsHistoryBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) FusionRtsHistoryBuilder.prototype[Symbol.dispose] = FusionRtsHistoryBuilder.prototype.free;
+exports.FusionRtsHistoryBuilder = FusionRtsHistoryBuilder;
+
 /**
  * WGS84 geodesic input failure class exposed as a stable enum symbol.
  * @enum {0}
@@ -5824,6 +5924,20 @@ class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Propagate and record the transition for later fusion RTS smoothing.
+     * @param {any} sample
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    propagateRecorded(sample, history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_propagateRecorded(this.__wbg_ptr, sample, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Restore this filter from versioned fusion-state bytes.
      * @param {Uint8Array} bytes
@@ -5881,6 +5995,20 @@ class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Apply a loose GNSS fix and record checkpoints for fusion RTS smoothing.
+     * @param {any} measurement
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateLooseRecorded(measurement, history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateLooseRecorded(this.__wbg_ptr, measurement, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
      * @param {any} measurement
@@ -5907,6 +6035,22 @@ class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Apply a tight broadcast update and record checkpoints for fusion RTS smoothing.
+     * @param {BroadcastEphemeris} broadcast
+     * @param {any} epoch
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateTightBroadcastRecorded(broadcast, epoch, history) {
+        _assertClass(broadcast, BroadcastEphemeris);
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateTightBroadcastRecorded(this.__wbg_ptr, broadcast.__wbg_ptr, epoch, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a tight broadcast update, replaying retained IMU checkpoints when it is late.
      * @param {BroadcastEphemeris} broadcast
@@ -5935,6 +6079,22 @@ class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Apply a tight SP3 update and record checkpoints for fusion RTS smoothing.
+     * @param {Sp3} sp3
+     * @param {any} epoch
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateTightSp3Recorded(sp3, epoch, history) {
+        _assertClass(sp3, Sp3);
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateTightSp3Recorded(this.__wbg_ptr, sp3.__wbg_ptr, epoch, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a tight SP3 update, replaying retained IMU checkpoints when it is late.
      * @param {Sp3} sp3
@@ -15490,6 +15650,49 @@ class SmoothCodeResult {
 if (Symbol.dispose) SmoothCodeResult.prototype[Symbol.dispose] = SmoothCodeResult.prototype.free;
 exports.SmoothCodeResult = SmoothCodeResult;
 
+/**
+ * Smoothed fusion trajectory returned by fixed-interval RTS smoothing.
+ */
+class SmoothedFusionTrajectory {
+    static __wrap(ptr) {
+        const obj = Object.create(SmoothedFusionTrajectory.prototype);
+        obj.__wbg_ptr = ptr;
+        SmoothedFusionTrajectoryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SmoothedFusionTrajectoryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_smoothedfusiontrajectory_free(ptr, 0);
+    }
+    /**
+     * Number of smoothed epochs.
+     * @returns {number}
+     */
+    get epochCount() {
+        const ret = wasm.smoothedfusiontrajectory_epochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Smoothed epochs in the same order as the recorded history.
+     * @returns {any}
+     */
+    get epochs() {
+        const ret = wasm.smoothedfusiontrajectory_epochs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) SmoothedFusionTrajectory.prototype[Symbol.dispose] = SmoothedFusionTrajectory.prototype.free;
+exports.SmoothedFusionTrajectory = SmoothedFusionTrajectory;
+
 class SmoothedTrack {
     static __wrap(ptr) {
         const obj = Object.create(SmoothedTrack.prototype);
@@ -27076,6 +27279,21 @@ function smoothCode(arc, options, hatch_window_cap) {
 }
 exports.smoothCode = smoothCode;
 
+/**
+ * Apply fixed-interval RTS smoothing to recorded fusion history.
+ * @param {FusionRtsHistory} history
+ * @returns {SmoothedFusionTrajectory}
+ */
+function smoothFusionRts(history) {
+    _assertClass(history, FusionRtsHistory);
+    const ret = wasm.smoothFusionRts(history.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SmoothedFusionTrajectory.__wrap(ret[0]);
+}
+exports.smoothFusionRts = smoothFusionRts;
+
 /**
  * Dual-frequency ionosphere-free Hatch carrier-smoothed code.
  * @param {any} arc
@@ -29024,6 +29242,12 @@ const FrameScannerFinalization = (typeof FinalizationRegistry === 'undefined')
 const FrameStatesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_framestates_free(ptr, 1));
+const FusionRtsHistoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fusionrtshistory_free(ptr, 1));
+const FusionRtsHistoryBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fusionrtshistorybuilder_free(ptr, 1));
 const GeofenceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geofence_free(ptr, 1));
@@ -29324,6 +29548,9 @@ const SlipResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const SmoothCodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smoothcoderesult_free(ptr, 1));
+const SmoothedFusionTrajectoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_smoothedfusiontrajectory_free(ptr, 1));
 const SmoothedTrackFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smoothedtrack_free(ptr, 1));