@neilberkman/sidereon 0.24.0 → 0.26.0

package/pkg-node/sidereon.js

@@ -920,6 +920,22 @@ class BroadcastEphemeris {
         }
         return ret[0] === 0 ? undefined : BroadcastStoreEvaluation.__wrap(ret[0]);
     }
+    /**
+     * Run fault detection and exclusion against this broadcast ephemeris.
+     *
+     * `request` is the SPP solve request plus the RAIM/exclusion options, the
+     * same object accepted by `Sp3.fde`. Delegates to
+     * `sidereon_core::quality::fde_spp` over the broadcast store.
+     * @param {any} request
+     * @returns {FdeSolution}
+     */
+    fde(request) {
+        const ret = wasm.broadcastephemeris_fde(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return FdeSolution.__wrap(ret[0]);
+    }
     /**
      * Number of usable GLONASS records.
      * @returns {number}
@@ -14664,6 +14680,91 @@ class RinexObsRepair {
 if (Symbol.dispose) RinexObsRepair.prototype[Symbol.dispose] = RinexObsRepair.prototype.free;
 exports.RinexObsRepair = RinexObsRepair;
 
+/**
+ * Per-epoch results returned by `solveSppFromRinexObs`.
+ */
+class RinexSppSolutionBatch {
+    static __wrap(ptr) {
+        const obj = Object.create(RinexSppSolutionBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        RinexSppSolutionBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RinexSppSolutionBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rinexsppsolutionbatch_free(ptr, 0);
+    }
+    /**
+     * Number of assembled RINEX epochs in the batch.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.rinexsppsolutionbatch_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Original RINEX OBS epoch index for assembled batch item `index`.
+     * @param {number} index
+     * @returns {number}
+     */
+    epochIndex(index) {
+        const ret = wasm.rinexsppsolutionbatch_epochIndex(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * The solve error for assembled batch item `index`, or `undefined`.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    error(index) {
+        const ret = wasm.rinexsppsolutionbatch_error(this.__wbg_ptr, index);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether assembled batch item `index` converged to a solution.
+     * @param {number} index
+     * @returns {boolean}
+     */
+    isOk(index) {
+        const ret = wasm.rinexsppsolutionbatch_isOk(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * The SPP solution for assembled batch item `index`.
+     * @param {number} index
+     * @returns {SppSolution}
+     */
+    solution(index) {
+        const ret = wasm.rinexsppsolutionbatch_solution(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SppSolution.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RinexSppSolutionBatch.prototype[Symbol.dispose] = RinexSppSolutionBatch.prototype.free;
+exports.RinexSppSolutionBatch = RinexSppSolutionBatch;
+
 /**
  * Stateful MSM lock-time tracker for deriving RINEX LLI continuity bits.
  */
@@ -21235,6 +21336,21 @@ function atmosphereSpaceWeatherDefaults() {
 }
 exports.atmosphereSpaceWeatherDefaults = atmosphereSpaceWeatherDefaults;
 
+/**
+ * Circular autocorrelation over all lags for a bipolar code vector.
+ * @param {Int8Array} code
+ * @returns {Int32Array}
+ */
+function autocorrelation(code) {
+    const ptr0 = passArray8ToWasm0(code, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.autocorrelation(ptr0, len0);
+    var v2 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+exports.autocorrelation = autocorrelation;
+
 /**
  * Solar beta angle in degrees from orbit normal and Sun vectors.
  * @param {Float64Array} orbit_normal
@@ -21705,6 +21821,50 @@ function correlate(iq, prn, options) {
 }
 exports.correlate = correlate;
 
+/**
+ * Coherently correlate interleaved IQ samples against an explicit bipolar code.
+ *
+ * `iq` is `[i0, q0, i1, q1, ...]`. The coherent sum follows the core
+ * `zip(iq, code)` semantics and therefore uses the shorter non-empty input.
+ * @param {Float64Array} iq
+ * @param {Int8Array} code
+ * @param {number} sample_rate_hz
+ * @param {number} doppler_hz
+ * @returns {CorrelationResult}
+ */
+function correlateAgainst(iq, code, sample_rate_hz, doppler_hz) {
+    const ptr0 = passArrayF64ToWasm0(iq, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(code, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.correlateAgainst(ptr0, len0, ptr1, len1, sample_rate_hz, doppler_hz);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CorrelationResult.__wrap(ret[0]);
+}
+exports.correlateAgainst = correlateAgainst;
+
+/**
+ * Single-lag circular correlation for two equal-length bipolar codes.
+ * @param {Int8Array} code_a
+ * @param {Int8Array} code_b
+ * @param {bigint} lag
+ * @returns {number}
+ */
+function correlationAt(code_a, code_b, lag) {
+    const ptr0 = passArray8ToWasm0(code_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(code_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.correlationAt(ptr0, len0, ptr1, len1, lag);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.correlationAt = correlationAt;
+
 /**
  * Fitted parameter covariance from a converged solve, scaling `(J^T J)^-1` by
  * the post-fit reduced chi-square `s_sq = 2 * cost / (m - n)` (the same scale
@@ -21792,6 +21952,27 @@ function coverageLookAngles(satellites, stations, epoch_unix_us) {
 }
 exports.coverageLookAngles = coverageLookAngles;
 
+/**
+ * Circular cross-correlation over all lags for two equal-length bipolar codes.
+ * @param {Int8Array} code_a
+ * @param {Int8Array} code_b
+ * @returns {Int32Array}
+ */
+function crossCorrelation(code_a, code_b) {
+    const ptr0 = passArray8ToWasm0(code_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(code_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.crossCorrelation(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+exports.crossCorrelation = crossCorrelation;
+
 /**
  * @param {any} rel
  * @param {number} n_rad_s
@@ -27042,6 +27223,26 @@ function raimFdeDesign(rows, options) {
 }
 exports.raimFdeDesign = raimFdeDesign;
 
+/**
+ * Run residual chi-square RAIM directly over an existing SPP solution.
+ *
+ * `solution` is a `SppSolution` from `solveSpp`, `solveBroadcast`, fallback,
+ * or a RINEX OBS convenience result. `options` is the same `RaimOptions` object
+ * accepted by `raim`; omit it for the core defaults.
+ * @param {SppSolution} solution
+ * @param {any} options
+ * @returns {any}
+ */
+function raimForSolution(solution, options) {
+    _assertClass(solution, SppSolution);
+    const ret = wasm.raimForSolution(solution.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.raimForSolution = raimForSolution;
+
 /**
  * Convert a pseudorange rate in metres per second to Doppler shift in hertz.
  * @param {number} range_rate_m_s
@@ -28383,6 +28584,29 @@ function solveRtkFloat(config) {
 }
 exports.solveRtkFloat = solveRtkFloat;
 
+/**
+ * Solve parsed RINEX OBS epochs serially against a broadcast ephemeris store.
+ *
+ * `rinexOptions` controls observation assembly; `solveOptions` accepts
+ * `withGeodetic`, `maxPdop`, and `coarseSearchSeeds`. The returned batch keeps
+ * per-epoch solve failures, so use `isOk(index)` before `solution(index)`.
+ * @param {BroadcastEphemeris} source
+ * @param {RinexObs} obs
+ * @param {any} rinex_options
+ * @param {any} solve_options
+ * @returns {RinexSppSolutionBatch}
+ */
+function solveSppFromRinexObs(source, obs, rinex_options, solve_options) {
+    _assertClass(source, BroadcastEphemeris);
+    _assertClass(obs, RinexObs);
+    const ret = wasm.solveSppFromRinexObs(source.__wbg_ptr, obs.__wbg_ptr, rinex_options, solve_options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RinexSppSolutionBatch.__wrap(ret[0]);
+}
+exports.solveSppFromRinexObs = solveSppFromRinexObs;
+
 /**
  * Solve SPP using an SBAS-corrected broadcast source and optional SBAS iono.
  *
@@ -28750,6 +28974,28 @@ function splitJdToJ2000Seconds(jd_whole, jd_fraction) {
 }
 exports.splitJdToJ2000Seconds = splitJdToJ2000Seconds;
 
+/**
+ * Assemble parsed RINEX OBS epochs into broadcast-backed SPP solve inputs.
+ *
+ * `source` is a parsed RINEX NAV broadcast store. `options` accepts
+ * `signalPolicy`, `corrections`, `initialGuess`, `satellites`, `met`, and
+ * `robust`; omit it for the core default policy for the observation file.
+ * @param {BroadcastEphemeris} source
+ * @param {RinexObs} obs
+ * @param {any} options
+ * @returns {any}
+ */
+function sppInputsFromRinexObs(source, obs, options) {
+    _assertClass(source, BroadcastEphemeris);
+    _assertClass(obs, RinexObs);
+    const ret = wasm.sppInputsFromRinexObs(source.__wbg_ptr, obs.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sppInputsFromRinexObs = sppInputsFromRinexObs;
+
 /**
  * @param {BroadcastEphemeris} broadcast
  * @param {SsrCorrectionStore} store
@@ -30413,6 +30659,9 @@ const RinexObsFinalization = (typeof FinalizationRegistry === 'undefined')
 const RinexObsRepairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rinexobsrepair_free(ptr, 1));
+const RinexSppSolutionBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rinexsppsolutionbatch_free(ptr, 1));
 const RtcmLockTimeTrackerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rtcmlocktimetracker_free(ptr, 1));