@neilberkman/sidereon 0.23.0 → 0.25.0

package/pkg/sidereon.js

@@ -910,6 +910,22 @@ export 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}
@@ -14501,6 +14517,90 @@ export class RinexObsRepair {
 }
 if (Symbol.dispose) RinexObsRepair.prototype[Symbol.dispose] = RinexObsRepair.prototype.free;
 
+/**
+ * Per-epoch results returned by `solveSppFromRinexObs`.
+ */
+export 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;
+
 /**
  * Stateful MSM lock-time tracker for deriving RINEX LLI continuity bits.
  */
@@ -20985,6 +21085,20 @@ export function atmosphereSpaceWeatherDefaults() {
     return SpaceWeatherDefaults.__wrap(ret);
 }
 
+/**
+ * Circular autocorrelation over all lags for a bipolar code vector.
+ * @param {Int8Array} code
+ * @returns {Int32Array}
+ */
+export 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;
+}
+
 /**
  * Solar beta angle in degrees from orbit normal and Sun vectors.
  * @param {Float64Array} orbit_normal
@@ -21429,6 +21543,48 @@ export function correlate(iq, prn, options) {
     return CorrelationResult.__wrap(ret[0]);
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
+/**
+ * Single-lag circular correlation for two equal-length bipolar codes.
+ * @param {Int8Array} code_a
+ * @param {Int8Array} code_b
+ * @param {bigint} lag
+ * @returns {number}
+ */
+export 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];
+}
+
 /**
  * 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
@@ -21512,6 +21668,26 @@ export function coverageLookAngles(satellites, stations, epoch_unix_us) {
     return CoverageGrid.__wrap(ret[0]);
 }
 
+/**
+ * Circular cross-correlation over all lags for two equal-length bipolar codes.
+ * @param {Int8Array} code_a
+ * @param {Int8Array} code_b
+ * @returns {Int32Array}
+ */
+export 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;
+}
+
 /**
  * @param {any} rel
  * @param {number} n_rad_s
@@ -26454,6 +26630,26 @@ export function pseudorangeVariance(elevation_deg, options) {
     return ret[0];
 }
 
+/**
+ * Run direct post-solve residual RAIM.
+ *
+ * `input` is `{ usedSats, residualsM }`. Use `options` fields `pFa`,
+ * `nSystems`, and either `weights` or `weightEntries` with `varianceOptions`.
+ * The result has the fault flag, chi-square statistic, threshold, largest
+ * normalized residual satellite, reduced chi-square, normalized residual map,
+ * RMS residual, and degrees of freedom.
+ * @param {any} input
+ * @param {any} options
+ * @returns {any}
+ */
+export function raim(input, options) {
+    const ret = wasm.raim(input, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Run standalone range RAIM/FDE over a linearized measurement set.
  *
@@ -26462,9 +26658,10 @@ export function pseudorangeVariance(elevation_deg, options) {
  * estimated state dimension). `options` is an optional `{ pFa?, maxExclusions?,
  * minRedundancy? }` object (pass `undefined` for the core defaults). Returns the
  * protected state correction, covariance, global chi-square test, the excluded
- * ids, the per-measurement diagnostics, and the exclusion count. Delegates to
- * `sidereon_core::quality::raim_fde_design`. Throws a `TypeError` for malformed
- * input and an `Error` for a rank-deficient or otherwise rejected set.
+ * ids, the per-measurement diagnostics, and the exclusion count. FDE
+ * computation runs in `sidereon_core::quality::raim_fde_design`.
+ * Malformed input throws a `TypeError`; a rank-deficient or rejected set throws
+ * an `Error`.
  * @param {any} rows
  * @param {any} options
  * @returns {any}
@@ -26477,6 +26674,25 @@ export function raimFdeDesign(rows, options) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * Convert a pseudorange rate in metres per second to Doppler shift in hertz.
  * @param {number} range_rate_m_s
@@ -27750,6 +27966,28 @@ export function solveRtkFloat(config) {
     return RtkFloatSolution.__wrap(ret[0]);
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * Solve SPP using an SBAS-corrected broadcast source and optional SBAS iono.
  *
@@ -28099,6 +28337,27 @@ export function splitJdToJ2000Seconds(jd_whole, jd_fraction) {
     return ret;
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * @param {BroadcastEphemeris} broadcast
  * @param {SsrCorrectionStore} store
@@ -29722,6 +29981,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));