@neilberkman/sidereon 0.20.0 → 0.22.0

package/pkg-node/sidereon.d.ts

@@ -2420,6 +2420,22 @@ export class GnssInsFilter {
      * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
      */
     updateLooseTimeSync(measurement: any): any;
+    /**
+     * Apply a gated wheeled-vehicle non-holonomic constraint update.
+     */
+    updateNonHolonomic(): any;
+    /**
+     * Apply a non-holonomic constraint and record checkpoints when an update applies.
+     */
+    updateNonHolonomicRecorded(history: FusionRtsHistoryBuilder): any;
+    /**
+     * Apply a gated zero-velocity and zero-angular-rate update.
+     */
+    updateStationary(): any;
+    /**
+     * Apply a stationary update and record checkpoints when an update applies.
+     */
+    updateStationaryRecorded(history: FusionRtsHistoryBuilder): any;
     /**
      * Apply a tight raw-observation epoch against a broadcast ephemeris source.
      */
@@ -6411,6 +6427,99 @@ export class Sp3ClockReferenceOffset {
     readonly satellites: number;
 }
 
+/**
+ * One coordinate-label reconciliation applied before SP3 merge consensus.
+ */
+export class Sp3FrameReconciliationReport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Caller assertion set, empty unless assertion reconciliation was used.
+     */
+    readonly assertedLabelSet: string[];
+    /**
+     * True when the published catalog row was applied in reverse.
+     */
+    readonly catalogInverse: boolean;
+    /**
+     * Source frame of the published catalog row used for Helmert reconciliation.
+     */
+    readonly catalogSourceFrame: string | undefined;
+    /**
+     * Target frame of the published catalog row used for Helmert reconciliation.
+     */
+    readonly catalogTargetFrame: string | undefined;
+    /**
+     * Inclusive decimal-year span of affected records.
+     */
+    readonly epochYearSpan: Float64Array;
+    /**
+     * True when both labels resolved to the same terrestrial realization.
+     */
+    readonly identity: boolean;
+    /**
+     * Reconciliation mechanism: "asserted_equivalence" or "helmert".
+     */
+    readonly method: string;
+    /**
+     * Published-table provenance for the catalog entry.
+     */
+    readonly provenance: string | undefined;
+    /**
+     * Number of satellite position records covered by the reconciliation.
+     */
+    readonly recordsAffected: number;
+    /**
+     * Published transform reference epoch, if a catalog entry was used.
+     */
+    readonly referenceEpochYear: number | undefined;
+    /**
+     * Rotation parameters in milliarcseconds, empty for non-catalog identity.
+     */
+    readonly rotationMas: Float64Array;
+    /**
+     * Rotation rates in milliarcseconds per year.
+     */
+    readonly rotationMasPerYear: Float64Array;
+    /**
+     * Scale parameter in parts per billion, undefined for non-catalog identity.
+     */
+    readonly scalePpb: number | undefined;
+    /**
+     * Scale rate in parts per billion per year.
+     */
+    readonly scalePpbPerYear: number | undefined;
+    /**
+     * Resolved source terrestrial frame for Helmert reconciliation.
+     */
+    readonly sourceFrame: string | undefined;
+    /**
+     * Source index in the mergeSp3 input array.
+     */
+    readonly sourceIndex: number;
+    /**
+     * Original coordinate-system label on that source.
+     */
+    readonly sourceLabel: string;
+    /**
+     * Resolved target terrestrial frame for Helmert reconciliation.
+     */
+    readonly targetFrame: string | undefined;
+    /**
+     * Target coordinate-system label, taken from source 0.
+     */
+    readonly targetLabel: string;
+    /**
+     * Translation parameters in millimetres, empty for non-catalog identity.
+     */
+    readonly translationMm: Float64Array;
+    /**
+     * Translation rates in millimetres per year.
+     */
+    readonly translationMmPerYear: Float64Array;
+}
+
 /**
  * A batch of interpolated SP3 states.
  */
@@ -6469,6 +6578,11 @@ export class Sp3MergeReport {
      */
     readonly agreement: Sp3AgreementMetric[];
     readonly agreementCount: number;
+    readonly frameReconciliationCount: number;
+    /**
+     * Coordinate-label reconciliations applied before consensus.
+     */
+    readonly frameReconciliations: Sp3FrameReconciliationReport[];
     readonly positionOutlierCount: number;
     /**
      * Cells where an accepted consensus rejected source outliers.
@@ -10547,6 +10661,11 @@ export function solveSppSbas(broadcast: BroadcastEphemeris, store: SbasCorrectio
  */
 export function solveStatic(sp3: Sp3, epochs: any, options: any): StaticSolution;
 
+/**
+ * Solve one static reference-station coordinate from paired RINEX OBS plus SP3.
+ */
+export function solveStaticReferenceStationRinex(ephemeris: Sp3, reference_obs: RinexObs, rover_obs: RinexObs, config: any): any;
+
 /**
  * Solve one static RTK baseline directly from paired RINEX OBS plus SP3.
  *
@@ -10874,6 +10993,11 @@ export function validate(records: any): any;
  */
 export function validateAgainstSp3Ids(records: any, ids: any): any;
 
+/**
+ * Blend a first good post-outage fix back over an outage span.
+ */
+export function velocityMatchOutage(states: any, first_good_fix: any, config: any): any;
+
 /**
  * Estimate robust station velocity with the MIDAS method.
  *

package/pkg-node/sidereon.js

@@ -6021,6 +6021,54 @@ class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Apply a gated wheeled-vehicle non-holonomic constraint update.
+     * @returns {any}
+     */
+    updateNonHolonomic() {
+        const ret = wasm.gnssinsfilter_updateNonHolonomic(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a non-holonomic constraint and record checkpoints when an update applies.
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateNonHolonomicRecorded(history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateNonHolonomicRecorded(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a gated zero-velocity and zero-angular-rate update.
+     * @returns {any}
+     */
+    updateStationary() {
+        const ret = wasm.gnssinsfilter_updateStationary(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a stationary update and record checkpoints when an update applies.
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateStationaryRecorded(history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateStationaryRecorded(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a tight raw-observation epoch against a broadcast ephemeris source.
      * @param {BroadcastEphemeris} broadcast
@@ -16333,6 +16381,259 @@ class Sp3ClockReferenceOffset {
 if (Symbol.dispose) Sp3ClockReferenceOffset.prototype[Symbol.dispose] = Sp3ClockReferenceOffset.prototype.free;
 exports.Sp3ClockReferenceOffset = Sp3ClockReferenceOffset;
 
+/**
+ * One coordinate-label reconciliation applied before SP3 merge consensus.
+ */
+class Sp3FrameReconciliationReport {
+    static __wrap(ptr) {
+        const obj = Object.create(Sp3FrameReconciliationReport.prototype);
+        obj.__wbg_ptr = ptr;
+        Sp3FrameReconciliationReportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Sp3FrameReconciliationReportFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sp3framereconciliationreport_free(ptr, 0);
+    }
+    /**
+     * Caller assertion set, empty unless assertion reconciliation was used.
+     * @returns {string[]}
+     */
+    get assertedLabelSet() {
+        const ret = wasm.sp3framereconciliationreport_assertedLabelSet(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * True when the published catalog row was applied in reverse.
+     * @returns {boolean}
+     */
+    get catalogInverse() {
+        const ret = wasm.sp3framereconciliationreport_catalogInverse(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Source frame of the published catalog row used for Helmert reconciliation.
+     * @returns {string | undefined}
+     */
+    get catalogSourceFrame() {
+        const ret = wasm.sp3framereconciliationreport_catalogSourceFrame(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Target frame of the published catalog row used for Helmert reconciliation.
+     * @returns {string | undefined}
+     */
+    get catalogTargetFrame() {
+        const ret = wasm.sp3framereconciliationreport_catalogTargetFrame(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Inclusive decimal-year span of affected records.
+     * @returns {Float64Array}
+     */
+    get epochYearSpan() {
+        const ret = wasm.sp3framereconciliationreport_epochYearSpan(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * True when both labels resolved to the same terrestrial realization.
+     * @returns {boolean}
+     */
+    get identity() {
+        const ret = wasm.sp3framereconciliationreport_identity(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Reconciliation mechanism: "asserted_equivalence" or "helmert".
+     * @returns {string}
+     */
+    get method() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sp3framereconciliationreport_method(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);
+        }
+    }
+    /**
+     * Published-table provenance for the catalog entry.
+     * @returns {string | undefined}
+     */
+    get provenance() {
+        const ret = wasm.sp3framereconciliationreport_provenance(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Number of satellite position records covered by the reconciliation.
+     * @returns {number}
+     */
+    get recordsAffected() {
+        const ret = wasm.sp3framereconciliationreport_recordsAffected(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Published transform reference epoch, if a catalog entry was used.
+     * @returns {number | undefined}
+     */
+    get referenceEpochYear() {
+        const ret = wasm.sp3framereconciliationreport_referenceEpochYear(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Rotation parameters in milliarcseconds, empty for non-catalog identity.
+     * @returns {Float64Array}
+     */
+    get rotationMas() {
+        const ret = wasm.sp3framereconciliationreport_rotationMas(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Rotation rates in milliarcseconds per year.
+     * @returns {Float64Array}
+     */
+    get rotationMasPerYear() {
+        const ret = wasm.sp3framereconciliationreport_rotationMasPerYear(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Scale parameter in parts per billion, undefined for non-catalog identity.
+     * @returns {number | undefined}
+     */
+    get scalePpb() {
+        const ret = wasm.sp3framereconciliationreport_scalePpb(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Scale rate in parts per billion per year.
+     * @returns {number | undefined}
+     */
+    get scalePpbPerYear() {
+        const ret = wasm.sp3framereconciliationreport_scalePpbPerYear(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Resolved source terrestrial frame for Helmert reconciliation.
+     * @returns {string | undefined}
+     */
+    get sourceFrame() {
+        const ret = wasm.sp3framereconciliationreport_sourceFrame(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Source index in the mergeSp3 input array.
+     * @returns {number}
+     */
+    get sourceIndex() {
+        const ret = wasm.sp3framereconciliationreport_sourceIndex(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Original coordinate-system label on that source.
+     * @returns {string}
+     */
+    get sourceLabel() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sp3framereconciliationreport_sourceLabel(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);
+        }
+    }
+    /**
+     * Resolved target terrestrial frame for Helmert reconciliation.
+     * @returns {string | undefined}
+     */
+    get targetFrame() {
+        const ret = wasm.sp3framereconciliationreport_targetFrame(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Target coordinate-system label, taken from source 0.
+     * @returns {string}
+     */
+    get targetLabel() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sp3framereconciliationreport_targetLabel(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);
+        }
+    }
+    /**
+     * Translation parameters in millimetres, empty for non-catalog identity.
+     * @returns {Float64Array}
+     */
+    get translationMm() {
+        const ret = wasm.sp3framereconciliationreport_translationMm(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Translation rates in millimetres per year.
+     * @returns {Float64Array}
+     */
+    get translationMmPerYear() {
+        const ret = wasm.sp3framereconciliationreport_translationMmPerYear(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) Sp3FrameReconciliationReport.prototype[Symbol.dispose] = Sp3FrameReconciliationReport.prototype.free;
+exports.Sp3FrameReconciliationReport = Sp3FrameReconciliationReport;
+
 /**
  * A batch of interpolated SP3 states.
  */
@@ -16484,6 +16785,23 @@ class Sp3MergeReport {
         const ret = wasm.sp3mergereport_agreementCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @returns {number}
+     */
+    get frameReconciliationCount() {
+        const ret = wasm.sp3mergereport_frameReconciliationCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Coordinate-label reconciliations applied before consensus.
+     * @returns {Sp3FrameReconciliationReport[]}
+     */
+    get frameReconciliations() {
+        const ret = wasm.sp3mergereport_frameReconciliations(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {number}
      */
@@ -27734,6 +28052,26 @@ function solveStatic(sp3, epochs, options) {
 }
 exports.solveStatic = solveStatic;
 
+/**
+ * Solve one static reference-station coordinate from paired RINEX OBS plus SP3.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} reference_obs
+ * @param {RinexObs} rover_obs
+ * @param {any} config
+ * @returns {any}
+ */
+function solveStaticReferenceStationRinex(ephemeris, reference_obs, rover_obs, config) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(reference_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.solveStaticReferenceStationRinex(ephemeris.__wbg_ptr, reference_obs.__wbg_ptr, rover_obs.__wbg_ptr, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.solveStaticReferenceStationRinex = solveStaticReferenceStationRinex;
+
 /**
  * Solve one static RTK baseline directly from paired RINEX OBS plus SP3.
  *
@@ -28613,6 +28951,22 @@ function validateAgainstSp3Ids(records, ids) {
 }
 exports.validateAgainstSp3Ids = validateAgainstSp3Ids;
 
+/**
+ * Blend a first good post-outage fix back over an outage span.
+ * @param {any} states
+ * @param {any} first_good_fix
+ * @param {any} config
+ * @returns {any}
+ */
+function velocityMatchOutage(states, first_good_fix, config) {
+    const ret = wasm.velocityMatchOutage(states, first_good_fix, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.velocityMatchOutage = velocityMatchOutage;
+
 /**
  * Estimate robust station velocity with the MIDAS method.
  *
@@ -29176,6 +29530,10 @@ function __wbg_get_imports() {
             const ret = Sp3ClockReferenceOffset.__wrap(arg0);
             return ret;
         },
+        __wbg_sp3framereconciliationreport_new: function(arg0) {
+            const ret = Sp3FrameReconciliationReport.__wrap(arg0);
+            return ret;
+        },
         __wbg_sp3mergeflag_new: function(arg0) {
             const ret = Sp3MergeFlag.__wrap(arg0);
             return ret;
@@ -29739,6 +30097,9 @@ const Sp3AgreementMetricFinalization = (typeof FinalizationRegistry === 'undefin
 const Sp3ClockReferenceOffsetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sp3clockreferenceoffset_free(ptr, 1));
+const Sp3FrameReconciliationReportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sp3framereconciliationreport_free(ptr, 1));
 const Sp3InterpolationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sp3interpolation_free(ptr, 1));