@neilberkman/sidereon 0.9.0 → 0.9.2

package/pkg/sidereon.js

@@ -3284,6 +3284,71 @@ export class Ephemeris {
 }
 if (Symbol.dispose) Ephemeris.prototype[Symbol.dispose] = Ephemeris.prototype.free;
 
+/**
+ * A confidence ellipse from a 2x2 covariance block: semi-axes scaled by the
+ * two-degree-of-freedom chi-square quantile `-2 ln(1 - confidence)`.
+ */
+export class ErrorEllipse2 {
+    static __wrap(ptr) {
+        const obj = Object.create(ErrorEllipse2.prototype);
+        obj.__wbg_ptr = ptr;
+        ErrorEllipse2Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ErrorEllipse2Finalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_errorellipse2_free(ptr, 0);
+    }
+    /**
+     * Two-degree-of-freedom chi-square scale `-2 ln(1 - confidence)`.
+     * @returns {number}
+     */
+    get chiSquareScale() {
+        const ret = wasm.errorellipse2_chiSquareScale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Requested confidence probability in `(0, 1)`.
+     * @returns {number}
+     */
+    get confidence() {
+        const ret = wasm.errorellipse2_confidence(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semi-major-axis orientation in radians, from the first (row/col 0) axis
+     * toward the second (row/col 1) axis.
+     * @returns {number}
+     */
+    get orientationRad() {
+        const ret = wasm.errorellipse2_orientationRad(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semi-major axis length (same unit as the square root of the covariance).
+     * @returns {number}
+     */
+    get semiMajor() {
+        const ret = wasm.errorellipse2_semiMajor(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semi-minor axis length.
+     * @returns {number}
+     */
+    get semiMinor() {
+        const ret = wasm.errorellipse2_semiMinor(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ErrorEllipse2.prototype[Symbol.dispose] = ErrorEllipse2.prototype.free;
+
 /**
  * A fault-detection-and-exclusion result: the surviving solution, the excluded
  * satellites in exclusion order, and the number of exclusions performed.
@@ -5264,6 +5329,201 @@ export class LeapSecondTable {
 }
 if (Symbol.dispose) LeapSecondTable.prototype[Symbol.dispose] = LeapSecondTable.prototype.free;
 
+/**
+ * A serial leave-one-out sweep: the base solve over all rows plus one re-solve
+ * per masked row, with the per-row optimum-cost shift.
+ */
+export class LeastSquaresDropOneReport {
+    static __wrap(ptr) {
+        const obj = Object.create(LeastSquaresDropOneReport.prototype);
+        obj.__wbg_ptr = ptr;
+        LeastSquaresDropOneReportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LeastSquaresDropOneReportFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_leastsquaresdroponereport_free(ptr, 0);
+    }
+    /**
+     * The solve over the full residual.
+     * @returns {LeastSquaresResult}
+     */
+    get base() {
+        const ret = wasm.leastsquaresdroponereport_base(this.__wbg_ptr);
+        return LeastSquaresResult.__wrap(ret);
+    }
+    /**
+     * `costDeltas[i] = dropAt(i).cost - base.cost`: how much the optimum cost
+     * moves when row `i` is removed. `Float64Array` of length `count`.
+     * @returns {Float64Array}
+     */
+    get costDeltas() {
+        const ret = wasm.leastsquaresdroponereport_costDeltas(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Number of masked-row re-solves (equals the residual-row count `m`).
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.leastsquaresdroponereport_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The solve with residual row `index` masked out. Throws a `RangeError` for
+     * an out-of-range index.
+     * @param {number} index
+     * @returns {LeastSquaresResult}
+     */
+    dropAt(index) {
+        const ret = wasm.leastsquaresdroponereport_dropAt(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return LeastSquaresResult.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) LeastSquaresDropOneReport.prototype[Symbol.dispose] = LeastSquaresDropOneReport.prototype.free;
+
+/**
+ * The outcome of one trust-region least-squares solve, mirroring the fields of
+ * `scipy.optimize.least_squares`'s `OptimizeResult`.
+ */
+export class LeastSquaresResult {
+    static __wrap(ptr) {
+        const obj = Object.create(LeastSquaresResult.prototype);
+        obj.__wbg_ptr = ptr;
+        LeastSquaresResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LeastSquaresResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_leastsquaresresult_free(ptr, 0);
+    }
+    /**
+     * Optimal cost `0.5 * sum(residual^2)` (after robust reweighting when a
+     * non-linear loss is used).
+     * @returns {number}
+     */
+    get cost() {
+        const ret = wasm.leastsquaresresult_cost(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Residual vector at the solution, `Float64Array` of length `m`.
+     * @returns {Float64Array}
+     */
+    get fun() {
+        const ret = wasm.leastsquaresresult_fun(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Gradient `J^T f` at the solution, `Float64Array` of length `n`.
+     * @returns {Float64Array}
+     */
+    get grad() {
+        const ret = wasm.leastsquaresresult_grad(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Row-major `m`-by-`n` Jacobian at the solution, flat `Float64Array` of
+     * length `m * n`.
+     * @returns {Float64Array}
+     */
+    get jac() {
+        const ret = wasm.leastsquaresresult_jac(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Residual row count `m`.
+     * @returns {number}
+     */
+    get m() {
+        const ret = wasm.leastsquaresresult_m(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Parameter count `n`.
+     * @returns {number}
+     */
+    get n() {
+        const ret = wasm.leastsquaresresult_n(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of residual evaluations.
+     * @returns {number}
+     */
+    get nfev() {
+        const ret = wasm.leastsquaresresult_nfev(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of Jacobian evaluations.
+     * @returns {number}
+     */
+    get njev() {
+        const ret = wasm.leastsquaresresult_njev(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * First-order optimality `||J^T f||_inf` at the solution.
+     * @returns {number}
+     */
+    get optimality() {
+        const ret = wasm.leastsquaresresult_optimality(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * SciPy-compatible termination status: `0` max evaluations, `1` gtol,
+     * `2` ftol, `3` xtol, `4` both ftol and xtol.
+     * @returns {number}
+     */
+    get status() {
+        const ret = wasm.leastsquaresresult_status(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether the solve converged (`status > 0`).
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.leastsquaresresult_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Solution parameter vector, `Float64Array` of length `n`.
+     * @returns {Float64Array}
+     */
+    get x() {
+        const ret = wasm.leastsquaresresult_x(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) LeastSquaresResult.prototype[Symbol.dispose] = LeastSquaresResult.prototype.free;
+
 /**
  * Link-budget inputs for [`LinkBudget.margin`].
  */
@@ -5761,6 +6021,117 @@ export class MappingFactors {
 }
 if (Symbol.dispose) MappingFactors.prototype[Symbol.dispose] = MappingFactors.prototype.free;
 
+/**
+ * One refined Moon elevation threshold crossing (moonrise / moonset).
+ */
+export class MoonElevationCrossing {
+    static __wrap(ptr) {
+        const obj = Object.create(MoonElevationCrossing.prototype);
+        obj.__wbg_ptr = ptr;
+        MoonElevationCrossingFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MoonElevationCrossingFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_moonelevationcrossing_free(ptr, 0);
+    }
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     * @returns {number}
+     */
+    get elevationDeg() {
+        const ret = wasm.moonelevationcrossing_elevationDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Crossing direction: `"rising"` (moonrise) or `"setting"` (moonset).
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.moonelevationcrossing_kind(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);
+        }
+    }
+    /**
+     * Refined crossing instant, unix microseconds.
+     * @returns {bigint}
+     */
+    get timeUnixUs() {
+        const ret = wasm.moonelevationcrossing_timeUnixUs(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MoonElevationCrossing.prototype[Symbol.dispose] = MoonElevationCrossing.prototype.free;
+
+/**
+ * One refined Moon meridian transit (culmination).
+ */
+export class MoonTransit {
+    static __wrap(ptr) {
+        const obj = Object.create(MoonTransit.prototype);
+        obj.__wbg_ptr = ptr;
+        MoonTransitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MoonTransitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_moontransit_free(ptr, 0);
+    }
+    /**
+     * Topocentric Moon elevation at the refined instant, degrees.
+     * @returns {number}
+     */
+    get elevationDeg() {
+        const ret = wasm.moontransit_elevationDeg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Culmination kind: `"upper"` (due south, highest) or `"lower"` (due north,
+     * lowest).
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.moontransit_kind(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);
+        }
+    }
+    /**
+     * Refined culmination instant, unix microseconds.
+     * @returns {bigint}
+     */
+    get timeUnixUs() {
+        const ret = wasm.moontransit_timeUnixUs(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MoonTransit.prototype[Symbol.dispose] = MoonTransit.prototype.free;
+
 /**
  * One solved moving-baseline epoch.
  */
@@ -8756,25 +9127,156 @@ export class PppFloatSolution {
 if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolution.prototype.free;
 
 /**
- * Predicted GNSS observables for one satellite at one receive epoch. Every
- * field is computed by `sidereon_core::observables::predict`.
+ * A precise-ephemeris source built from samples rather than parsed SP3 text.
+ *
+ * Implements the same `ObservableEphemerisSource` contract as a parsed [`Sp3`]
+ * product and shares its interpolation substrate, so [`predictRanges`] accepts
+ * either handle. Build one with [`preciseEphemerisSamplesFromSamples`].
  */
-export class PredictedObservables {
+export class PreciseEphemerisSampleSource {
     static __wrap(ptr) {
-        const obj = Object.create(PredictedObservables.prototype);
+        const obj = Object.create(PreciseEphemerisSampleSource.prototype);
         obj.__wbg_ptr = ptr;
-        PredictedObservablesFinalization.register(obj, obj.__wbg_ptr, obj);
+        PreciseEphemerisSampleSourceFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PredictedObservablesFinalization.unregister(this);
+        PreciseEphemerisSampleSourceFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_predictedobservables_free(ptr, 0);
+        wasm.__wbg_preciseephemerissamplesource_free(ptr, 0);
+    }
+    /**
+     * Predict geometric ranges for many requests in one call. See the shared
+     * [`predictRanges`](crate::precise_samples::predict_ranges_over) contract;
+     * this is the sample-source entry point.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.preciseephemerissamplesource_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The satellites this source can interpolate (e.g. `"G01"`), ascending.
+     * @returns {string[]}
+     */
+    get satellites() {
+        const ret = wasm.preciseephemerissamplesource_satellites(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) PreciseEphemerisSampleSource.prototype[Symbol.dispose] = PreciseEphemerisSampleSource.prototype.free;
+
+/**
+ * The per-request results of a batch observable prediction, index-aligned to
+ * the input requests. Each request independently either produced observables or
+ * failed; query a request with [`PredictBatch.isOk`] /
+ * [`PredictBatch.observables`] / [`PredictBatch.error`].
+ */
+export class PredictBatch {
+    static __wrap(ptr) {
+        const obj = Object.create(PredictBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        PredictBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PredictBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_predictbatch_free(ptr, 0);
+    }
+    /**
+     * Number of requests in the batch.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.predictbatch_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The failure message for request `index`, or `undefined` when it
+     * succeeded. Throws a `RangeError` for an out-of-range index.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    error(index) {
+        const ret = wasm.predictbatch_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 request `index` produced observables. Throws a `RangeError` for
+     * an out-of-range index.
+     * @param {number} index
+     * @returns {boolean}
+     */
+    isOk(index) {
+        const ret = wasm.predictbatch_isOk(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * The observables for request `index`. Throws a `RangeError` for an
+     * out-of-range index and an `Error` carrying that request's failure message
+     * when the prediction failed (check [`PredictBatch.isOk`] first).
+     * @param {number} index
+     * @returns {PredictedObservables}
+     */
+    observables(index) {
+        const ret = wasm.predictbatch_observables(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PredictedObservables.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) PredictBatch.prototype[Symbol.dispose] = PredictBatch.prototype.free;
+
+/**
+ * Predicted GNSS observables for one satellite at one receive epoch. Every
+ * field is computed by `sidereon_core::observables::predict`.
+ */
+export class PredictedObservables {
+    static __wrap(ptr) {
+        const obj = Object.create(PredictedObservables.prototype);
+        obj.__wbg_ptr = ptr;
+        PredictedObservablesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PredictedObservablesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_predictedobservables_free(ptr, 0);
     }
     /**
      * Topocentric azimuth in `[0, 360)`, degrees.
@@ -10278,6 +10780,25 @@ export class Sp3 {
         }
         return Sp3Interpolation.__wrap(ret[0]);
     }
+    /**
+     * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
+     * against this ephemeris in one call. `requests` is an array of
+     * `{ sat, receiverEcefM, tRxJ2000S }`; returns an array of
+     * `{ geometricRangeM, satClockS, transmitTimeJ2000S, satPosEcefM }`
+     * index-aligned to `requests`. The same call shape works on a
+     * `PreciseEphemerisSampleSource`. Delegates to the serial reference kernel
+     * `sidereon_core::observables::predict_ranges`.
+     * @param {any} requests
+     * @param {any} options
+     * @returns {any}
+     */
+    predictRanges(requests, options) {
+        const ret = wasm.sp3_predictRanges(this.__wbg_ptr, requests, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Satellite tokens present in the product (e.g. `"G01"`), ascending.
      * @returns {string[]}
@@ -12586,6 +13107,36 @@ export function correlate(iq, prn, options) {
     return CorrelationResult.__wrap(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
+ * `scipy.optimize.curve_fit` applies to its `pcov`).
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array` (the Jacobian at the
+ * solution), and `cost` is the solve's optimal cost `0.5 * sum(residual^2)`;
+ * the degrees of freedom `m - n` (taken from the Jacobian's own shape) must be
+ * positive. Pairs naturally with a [`crate::LeastSquaresResult`] (`result.jac`,
+ * `result.m`, `result.n`, `result.cost`). Returns the `n`-by-`n` covariance as
+ * a flat row-major `Float64Array`. Delegates to
+ * `sidereon_core::astro::math::least_squares::covariance_from_jacobian`.
+ * @param {Float64Array} jacobian
+ * @param {number} m
+ * @param {number} n
+ * @param {number} cost
+ * @returns {Float64Array}
+ */
+export function covarianceFromJacobian(jacobian, m, n, cost) {
+    const ptr0 = passArrayF64ToWasm0(jacobian, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.covarianceFromJacobian(ptr0, len0, m, n, cost);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Whether a 3x3 covariance (flat row-major length 9) is symmetric positive
  * semidefinite within the engine tolerance.
@@ -12834,6 +13385,37 @@ export function dishGain(diameter_m, frequency_hz, efficiency) {
     return ret[0];
 }
 
+/**
+ * GNSS dilution of precision with an explicit ENU convention for the
+ * horizontal/vertical split.
+ *
+ * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array` of ECEF unit
+ * vectors, `weights` a positive `Float64Array` of length `n`, and `convention`
+ * is `"geodeticNormal"` (the GNSS-standard default, matching [`gnssDop`]) or
+ * `"geocentricRadial"` (radial up). Only HDOP/VDOP differ between conventions
+ * (by ~`1e-3` relative); GDOP/PDOP/TDOP are identical. Delegates to
+ * `sidereon_core::geometry::dop_with_convention`.
+ * @param {Float64Array} line_of_sight
+ * @param {Float64Array} weights
+ * @param {Wgs84Geodetic} receiver
+ * @param {string} convention
+ * @returns {Dop}
+ */
+export function dopWithConvention(line_of_sight, weights, receiver, convention) {
+    const ptr0 = passArrayF64ToWasm0(line_of_sight, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(weights, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    _assertClass(receiver, Wgs84Geodetic);
+    const ptr2 = passStringToWasm0(convention, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.dopWithConvention(ptr0, len0, ptr1, len1, receiver.__wbg_ptr, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Dop.__wrap(ret[0]);
+}
+
 /**
  * Range rate and dimensionless Doppler ratio from a GCRS state.
  *
@@ -12975,6 +13557,53 @@ export function eclipseStatus(satellite_position_km, sun_position_km) {
     return v3;
 }
 
+/**
+ * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
+ * orthometric height and a geodetic position in radians, using the embedded
+ * genuine EGM96 1-degree model. Delegates to
+ * `sidereon_core::geoid::egm96_ellipsoidal_height_m`.
+ * @param {number} orthometric_height_m
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @returns {number}
+ */
+export function egm96EllipsoidalHeightM(orthometric_height_m, lat_rad, lon_rad) {
+    const ret = wasm.egm96EllipsoidalHeightM(orthometric_height_m, lat_rad, lon_rad);
+    return ret;
+}
+
+/**
+ * Orthometric height `H = h - N` (metres above mean sea level) from an
+ * ellipsoidal height and a geodetic position in radians, using the embedded
+ * genuine EGM96 1-degree model. Delegates to
+ * `sidereon_core::geoid::egm96_orthometric_height_m`.
+ * @param {number} ellipsoidal_height_m
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @returns {number}
+ */
+export function egm96OrthometricHeightM(ellipsoidal_height_m, lat_rad, lon_rad) {
+    const ret = wasm.egm96OrthometricHeightM(ellipsoidal_height_m, lat_rad, lon_rad);
+    return ret;
+}
+
+/**
+ * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
+ * position in radians, from the embedded GENUINE EGM96 1-degree global grid.
+ * Latitude is positive north, longitude positive east. This is the recommended
+ * zero-setup default for metre-class datum work (its bilinear lookup agrees
+ * with the full 15-arcminute EGM96 grid to ~0.4 m RMS); the coarse
+ * [`geoidUndulation`] is only suitable for sanity checks. Delegates to
+ * `sidereon_core::geoid::egm96_undulation`.
+ * @param {number} lat_rad
+ * @param {number} lon_rad
+ * @returns {number}
+ */
+export function egm96Undulation(lat_rad, lon_rad) {
+    const ret = wasm.egm96Undulation(lat_rad, lon_rad);
+    return ret;
+}
+
 /**
  * Effective isotropic radiated power, dBW.
  * @param {number} tx_power_dbm
@@ -13126,6 +13755,81 @@ export function encounterPlaneCovariance(frame, covariance_km2) {
     return v2;
 }
 
+/**
+ * Confidence ellipse from an arbitrary 2x2 covariance block.
+ *
+ * `covariance` is a flat row-major length-4 `Float64Array` (`[c00, c01, c10,
+ * c11]`); `confidence` is in `(0, 1)`. The semi-axes are the eigenvalues of the
+ * symmetrized block scaled by the chi-square(2) quantile. Throws a `RangeError`
+ * for a non-positive-semidefinite block or an out-of-range confidence.
+ * Delegates to `sidereon_core::geometry::error_ellipse_2x2`.
+ * @param {Float64Array} covariance
+ * @param {number} confidence
+ * @returns {ErrorEllipse2}
+ */
+export function errorEllipse2(covariance, confidence) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.errorEllipse2(ptr0, len0, confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ErrorEllipse2.__wrap(ret[0]);
+}
+
+/**
+ * Find Moon elevation threshold crossings (moonrise / moonset) over a UTC
+ * window.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `startUnixUs` / `endUnixUs` bound the window in unix microseconds. `options`
+ * is `{ elevationThresholdDeg?, stepSeconds?, timeToleranceSeconds? }`.
+ * Delegates to `sidereon_core::astro::bodies::find_moon_elevation_crossings`.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {any} options
+ * @returns {MoonElevationCrossing[]}
+ */
+export function findMoonElevationCrossings(latitude_deg, longitude_deg, altitude_km, start_unix_us, end_unix_us, options) {
+    const ret = wasm.findMoonElevationCrossings(latitude_deg, longitude_deg, altitude_km, start_unix_us, end_unix_us, options);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Find Moon meridian transits (upper and lower culminations) over a UTC window.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `startUnixUs` / `endUnixUs` bound the window in unix microseconds.
+ * `stepSeconds` is the uniform scan step and `timeToleranceSeconds` the
+ * refinement tolerance. Delegates to
+ * `sidereon_core::astro::bodies::find_moon_transits`.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} start_unix_us
+ * @param {bigint} end_unix_us
+ * @param {number} step_seconds
+ * @param {number} time_tolerance_seconds
+ * @returns {MoonTransit[]}
+ */
+export function findMoonTransits(latitude_deg, longitude_deg, altitude_km, start_unix_us, end_unix_us, step_seconds, time_tolerance_seconds) {
+    const ret = wasm.findMoonTransits(latitude_deg, longitude_deg, altitude_km, start_unix_us, end_unix_us, step_seconds, time_tolerance_seconds);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
 /**
  * Find local TCA candidates between two satellites over a UTC window.
  *
@@ -13837,6 +14541,43 @@ export function gnssVisible(sp3, station_ecef_m, j2000_seconds, options) {
     return v2;
 }
 
+/**
+ * GPS - UTC (the GNSS leap-second offset since the GPS epoch) on a UTC calendar
+ * date: the IS-GPS-200 quantity broadcast in the navigation message (18 s from
+ * 2017-01-01). Equals `taiUtcOffsetS - 19`. Use this, not [`taiUtcOffsetS`],
+ * whenever you mean the leap seconds a GPS receiver applies. Delegates to
+ * `sidereon_core::astro::time::scales::gps_utc_offset_s`.
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {number}
+ */
+export function gpsUtcOffsetS(year, month, day) {
+    const ret = wasm.gpsUtcOffsetS(year, month, day);
+    return ret;
+}
+
+/**
+ * Trace of the Gauss-Newton Hessian approximation `J^T J`: the sum of the
+ * squared column norms of the Jacobian, with no inverse formed.
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array`. Delegates to
+ * `sidereon_core::astro::math::least_squares::hessian_trace`.
+ * @param {Float64Array} jacobian
+ * @param {number} m
+ * @param {number} n
+ * @returns {number}
+ */
+export function hessianTrace(jacobian, m, n) {
+    const ptr0 = passArrayF64ToWasm0(jacobian, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hessianTrace(ptr0, len0, m, n);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Gauss angles-only orbit determination.
  *
@@ -14034,6 +14775,27 @@ export function j2000SecondsToCivil(seconds) {
     return CivilDateTime.__wrap(ret);
 }
 
+/**
+ * Jarque-Bera normality test on a residual set.
+ *
+ * `x` is a `Float64Array` (at least two values). Returns
+ * `{ statistic, pValue }` with `statistic = n/6 (S^2 + K^2/4)` (biased moments)
+ * and the chi-square(2) survival `pValue = exp(-statistic/2)`, matching
+ * `scipy.stats.jarque_bera`. Delegates to
+ * `sidereon_core::quality::normality::jarque_bera`.
+ * @param {Float64Array} x
+ * @returns {any}
+ */
+export function jarqueBera(x) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.jarqueBera(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * GPS broadcast Klobuchar ionospheric group delay in the model's native units
  * (positive metres).
@@ -14069,6 +14831,29 @@ export function klobucharDelay(alpha, beta, lat_deg, lon_deg, azimuth_deg, eleva
     return ret[0];
 }
 
+/**
+ * Sample kurtosis of a residual set.
+ *
+ * `x` is a `Float64Array`. `fisher` (default `true`) returns the excess
+ * kurtosis `m4 / m2^2 - 3` (Gaussian -> 0, `scipy.stats.kurtosis`); `false`
+ * returns the Pearson kurtosis (Gaussian -> 3). `bias` (default `true`); pass
+ * `false` for the sample correction (needs at least four values). Delegates to
+ * `sidereon_core::quality::normality::kurtosis`.
+ * @param {Float64Array} x
+ * @param {boolean | null} [fisher]
+ * @param {boolean | null} [bias]
+ * @returns {number}
+ */
+export function kurtosis(x, fisher, bias) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.kurtosis(ptr0, len0, isLikeNone(fisher) ? 0xFFFFFF : fisher ? 1 : 0, isLikeNone(bias) ? 0xFFFFFF : bias ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Resolve integer ambiguities with the LAMBDA method (RTKLIB `lambda()` port).
  *
@@ -14171,6 +14956,47 @@ export function leapSecondsBatch(dates) {
     return v2;
 }
 
+/**
+ * Solve a generic data-driven least-squares problem.
+ *
+ * `request` is a `DataProblemInput` object: a `kind` (`"linear"`,
+ * `"polynomial"`, `"exponential"`) carrying its data arrays, the `x0` starting
+ * point, and the SciPy `least_squares` options. The whole trust-region
+ * iteration runs in Rust through
+ * `trust_region_least_squares::data::solve_data_problem` (the serial entry, the
+ * default in-crate SVD backend); no rayon thread pool is entered.
+ * @param {any} request
+ * @returns {LeastSquaresResult}
+ */
+export function leastSquares(request) {
+    const ret = wasm.leastSquares(request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return LeastSquaresResult.__wrap(ret[0]);
+}
+
+/**
+ * Serial leave-one-out (jackknife) over a data-driven least-squares problem.
+ *
+ * Delegates to the core's serial leave-one-out entry
+ * `trust_region_least_squares::batch::solve_data_problem_drop_one_serial`: the
+ * full problem is solved once, then re-solved with each residual row masked in
+ * turn. The core's default `solve_data_problem_drop_one` fans these re-solves
+ * across a rayon pool that wasm has no threads for, so this binding takes the
+ * serial twin, which runs the identical re-solves one row at a time and is
+ * byte-identical to the parallel version.
+ * @param {any} request
+ * @returns {LeastSquaresDropOneReport}
+ */
+export function leastSquaresDropOne(request) {
+    const ret = wasm.leastSquaresDropOne(request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return LeastSquaresDropOneReport.__wrap(ret[0]);
+}
+
 /**
  * Decode LNAV subframes 1-3 back into engineering-unit parameters.
  *
@@ -14482,6 +15308,29 @@ export function mergeSp3(sources, options) {
     return Sp3MergeResult.__wrap(ret[0]);
 }
 
+/**
+ * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
+ *
+ * `x` is a `Float64Array`; `fisher` and `bias` select the kurtosis convention
+ * and the bias correction exactly as in [`skewness`] / [`kurtosis`] (both
+ * default `true`). Returns `{ mean, variance, skewness, kurtosisExcess }`; the
+ * variance is the biased second central moment. Delegates to
+ * `sidereon_core::quality::normality::moments`.
+ * @param {Float64Array} x
+ * @param {boolean | null} [fisher]
+ * @param {boolean | null} [bias]
+ * @returns {any}
+ */
+export function moments(x, fisher, bias) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.moments(ptr0, len0, isLikeNone(fisher) ? 0xFFFFFF : fisher ? 1 : 0, isLikeNone(bias) ? 0xFFFFFF : bias ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Angle in degrees between satellite nadir and the Moon direction.
  * @param {Float64Array} satellite_position_km
@@ -14502,6 +15351,64 @@ export function moonAngle(satellite_position_km, moon_position_km) {
     return v3;
 }
 
+/**
+ * Topocentric azimuth/elevation/range of the Moon from a ground site,
+ * including the diurnal parallax. See [`sunAzEl`] for the argument shapes.
+ * Delegates to `sidereon_core::astro::bodies::moon_az_el`.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} epoch_unix_us
+ * @returns {any}
+ */
+export function moonAzEl(latitude_deg, longitude_deg, altitude_km, epoch_unix_us) {
+    const ret = wasm.moonAzEl(latitude_deg, longitude_deg, altitude_km, epoch_unix_us);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Topocentric geometric Moon (disk-center) elevation from a ground site,
+ * degrees. See [`sunAzEl`] for the argument shapes. Delegates to
+ * `sidereon_core::astro::bodies::moon_az_el` and returns its `elevationDeg`: the
+ * core `moon_elevation_deg` convenience wrapper `expect`s on the geometry, so a
+ * valid-shaped but out-of-range station (e.g. latitude 120) would panic the
+ * wasm module; going through `moon_az_el` surfaces that as a thrown JS error.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} epoch_unix_us
+ * @returns {number}
+ */
+export function moonElevationDeg(latitude_deg, longitude_deg, altitude_km, epoch_unix_us) {
+    const ret = wasm.moonElevationDeg(latitude_deg, longitude_deg, altitude_km, epoch_unix_us);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Illuminated fraction of the Moon as seen from a ground site. Returns
+ * `{ illuminatedFraction, phaseAngleDeg }` (0 = new, 1 = full). See [`sunAzEl`]
+ * for the argument shapes. Delegates to
+ * `sidereon_core::astro::bodies::moon_illumination`.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} epoch_unix_us
+ * @returns {any}
+ */
+export function moonIllumination(latitude_deg, longitude_deg, altitude_km, epoch_unix_us) {
+    const ret = wasm.moonIllumination(latitude_deg, longitude_deg, altitude_km, epoch_unix_us);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Narrow-lane code combination, metres.
  * @param {number} p1_m
@@ -14594,6 +15501,36 @@ export function noiseAmplification(f1_hz, f2_hz) {
     return ret[0];
 }
 
+/**
+ * Parameter covariance from a design (Jacobian) matrix via the Gauss-Newton
+ * normal equations `varianceScale * (J^T J)^-1`, formed from the thin SVD of
+ * `J` (not by inverting `J^T J`, so the condition number is not squared).
+ *
+ * `jacobian` is a flat row-major `(m, n)` `Float64Array` with `m >= n`;
+ * `varianceScale` (`sigma^2`, non-negative) scales the bare cofactor (pass the
+ * post-fit reduced chi-square for the fitted covariance, or `1.0` for
+ * `(J^T J)^-1`). Returns the `n`-by-`n` covariance as a flat row-major
+ * `Float64Array` of length `n * n`. Throws an `Error` for a rank-deficient
+ * Jacobian. Delegates to
+ * `sidereon_core::astro::math::least_squares::normal_covariance`.
+ * @param {Float64Array} jacobian
+ * @param {number} m
+ * @param {number} n
+ * @param {number} variance_scale
+ * @returns {Float64Array}
+ */
+export function normalCovariance(jacobian, m, n, variance_scale) {
+    const ptr0 = passArrayF64ToWasm0(jacobian, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.normalCovariance(ptr0, len0, m, n, variance_scale);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Predict observables for one satellite from a broadcast ephemeris store.
  * Delegates to `sidereon_core::observables::predict`.
@@ -15101,6 +16038,86 @@ export function pppCorrections(sp3, epochs, receiver_ecef_m, options) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Build a sample-backed precise-ephemeris source from an array of samples.
+ *
+ * `samples` is an array of `{ sat, epoch, positionEcefM, clockS?, clockEvent? }`
+ * objects (see the sample field docs). Samples are grouped by satellite in their
+ * supplied order; each satellite needs at least two strictly time-increasing
+ * samples. Throws a `TypeError` for a malformed object or bad satellite token
+ * and a `RangeError` for a non-finite epoch or a source validation failure
+ * (empty input, a single-sample satellite, non-monotonic epochs, a non-finite
+ * sample). Delegates to `sidereon_core::sp3::PreciseEphemerisSamples::from_samples`.
+ * @param {any} samples
+ * @returns {PreciseEphemerisSampleSource}
+ */
+export function preciseEphemerisSamplesFromSamples(samples) {
+    const ret = wasm.preciseEphemerisSamplesFromSamples(samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PreciseEphemerisSampleSource.__wrap(ret[0]);
+}
+
+/**
+ * Predict observables for many `(satellite, receiver, epoch)` requests from a
+ * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
+ * shapes. Delegates to the serial `sidereon_core::observables::predict_batch`.
+ * @param {BroadcastEphemeris} broadcast
+ * @param {string[]} satellites
+ * @param {Float64Array} receivers_ecef_m
+ * @param {Float64Array} epochs_j2000_s
+ * @param {any} options
+ * @returns {PredictBatch}
+ */
+export function predictBatchBroadcast(broadcast, satellites, receivers_ecef_m, epochs_j2000_s, options) {
+    _assertClass(broadcast, BroadcastEphemeris);
+    const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(receivers_ecef_m, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(epochs_j2000_s, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.predictBatchBroadcast(broadcast.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PredictBatch.__wrap(ret[0]);
+}
+
+/**
+ * Predict observables for many `(satellite, receiver, epoch)` requests from an
+ * SP3 precise product, serially.
+ *
+ * `satellites` is an array of satellite tokens, `receiversEcefM` a flat
+ * row-major `(n, 3)` `Float64Array` of receiver ECEF positions (metres), and
+ * `epochsJ2000S` a `Float64Array` of receive epochs (seconds since J2000); all
+ * three are index-aligned and length `n`. Element `i` of the result corresponds
+ * to request `i`. Delegates to the serial reference kernel
+ * `sidereon_core::observables::predict_batch`; the binding never spawns the
+ * rayon thread pool the parallel variant uses.
+ * @param {Sp3} sp3
+ * @param {string[]} satellites
+ * @param {Float64Array} receivers_ecef_m
+ * @param {Float64Array} epochs_j2000_s
+ * @param {any} options
+ * @returns {PredictBatch}
+ */
+export function predictBatchSp3(sp3, satellites, receivers_ecef_m, epochs_j2000_s, options) {
+    _assertClass(sp3, Sp3);
+    const ptr0 = passArrayJsValueToWasm0(satellites, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(receivers_ecef_m, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(epochs_j2000_s, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.predictBatchSp3(sp3.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PredictBatch.__wrap(ret[0]);
+}
+
 /**
  * Prepare ionosphere-free single-frequency RTK arc inputs from a
  * dual-frequency arc and fixed wide-lane ambiguities.
@@ -15542,6 +16559,26 @@ export function shadowFraction(satellite_position_km, sun_position_km) {
     return v3;
 }
 
+/**
+ * Shapiro-Wilk normality test on a residual set.
+ *
+ * `x` is a `Float64Array` (at least three values). Returns `{ w, pValue }`,
+ * Royston's AS R94 port that `scipy.stats.shapiro` uses; `w` is in `(0, 1]`
+ * (closer to one is more Gaussian). Delegates to
+ * `sidereon_core::quality::normality::shapiro_wilk`.
+ * @param {Float64Array} x
+ * @returns {any}
+ */
+export function shapiroWilk(x) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.shapiroWilk(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Build satellite-keyed pseudorange sigmas in metres from `{ satelliteId,
  * elevationDeg, cn0Dbhz? }` entries. Invalid entries are dropped by the core.
@@ -15557,6 +16594,27 @@ export function sigmas(entries, options) {
     return SatelliteVector.__wrap(ret[0]);
 }
 
+/**
+ * Sample skewness of a residual set.
+ *
+ * `x` is a `Float64Array`. `bias` (default `true`) selects the Fisher-Pearson
+ * coefficient `g1 = m3 / m2^(3/2)` (`scipy.stats.skew`); `false` applies the
+ * sample correction (`scipy.stats.skew(bias=False)`, needs at least three
+ * values). Delegates to `sidereon_core::quality::normality::skewness`.
+ * @param {Float64Array} x
+ * @param {boolean | null} [bias]
+ * @returns {number}
+ */
+export function skewness(x, bias) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.skewness(ptr0, len0, isLikeNone(bias) ? 0xFFFFFF : bias ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Stable lower-case label for a slip reason.
  * @param {SlipReason} reason
@@ -15943,6 +17001,29 @@ export function solveWithFallback(precise, broadcast, request, policy) {
     return SourcedSolution.__wrap(ret[0]);
 }
 
+/**
+ * Extract a parsed SP3 product as the canonical precise-ephemeris samples, one
+ * per real position record in ascending epoch order.
+ *
+ * Returns an array of `{ sat, epoch, positionEcefM, clockS, clockEvent }`
+ * objects. Round-tripping the result back through
+ * [`preciseEphemerisSamplesFromSamples`] rebuilds an interpolatable source that
+ * reproduces the SP3-parsed source's interpolated states and predicted ranges
+ * to the documented round-trip precision (byte-identical for samples whose
+ * meters are the faithful image of the fit nodes; see the core module docs).
+ * Delegates to `sidereon_core::sp3::Sp3::precise_ephemeris_samples`.
+ * @param {Sp3} sp3
+ * @returns {any}
+ */
+export function sp3PreciseEphemerisSamples(sp3) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.sp3PreciseEphemerisSamples(sp3.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -16019,6 +17100,27 @@ export function sunAngle(satellite_position_km, sun_position_km) {
     return v3;
 }
 
+/**
+ * Topocentric azimuth/elevation/range of the Sun from a ground site.
+ *
+ * The station is geodetic (`latitudeDeg`, `longitudeDeg`, `altitudeKm`);
+ * `epochUnixUs` is the UTC instant as unix microseconds. Returns
+ * `{ azimuthDeg, elevationDeg, rangeKm }` (azimuth clockwise from north).
+ * Delegates to `sidereon_core::astro::bodies::sun_az_el`.
+ * @param {number} latitude_deg
+ * @param {number} longitude_deg
+ * @param {number} altitude_km
+ * @param {bigint} epoch_unix_us
+ * @returns {any}
+ */
+export function sunAzEl(latitude_deg, longitude_deg, altitude_km, epoch_unix_us) {
+    const ret = wasm.sunAzEl(latitude_deg, longitude_deg, altitude_km, epoch_unix_us);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Sun elevation in degrees above the satellite local horizontal plane.
  * @param {Float64Array} satellite_position_km
@@ -16071,6 +17173,22 @@ export function sunMoonEci(epochs_unix_us) {
     return SunMoon.__wrap(ret[0]);
 }
 
+/**
+ * TAI-UTC (cumulative leap seconds) in effect on a UTC calendar date.
+ *
+ * This is **not** the GNSS "GPS - UTC" offset; for the quantity a GPS receiver
+ * applies use [`gpsUtcOffsetS`] (they differ by a constant 19 s). Delegates to
+ * `sidereon_core::astro::time::scales::tai_utc_offset_s`.
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {number}
+ */
+export function taiUtcOffsetS(year, month, day) {
+    const ret = wasm.taiUtcOffsetS(year, month, day);
+    return ret;
+}
+
 /**
  * Transform a batch of TEME states to GCRS, each at its own epoch.
  *
@@ -16163,8 +17281,8 @@ export function timescaleOffsetAtS(from, to, utc_jd) {
  *
  * Covers the atomic scales (TAI/TT/GPST/GST/QZSST/BDT), whose mutual offsets
  * are constants fixed by their ICDs. Throws a `RangeError` when either scale is
- * UTC-based (`Utc`/`Glonasst`) — those carry leap seconds, so their offset is
- * epoch-dependent and needs [`timescaleOffsetAtS`] — or for `Tdb` (no fixed
+ * UTC-based (`Utc`/`Glonasst`): those carry leap seconds, so their offset is
+ * epoch-dependent and needs [`timescaleOffsetAtS`], or for `Tdb` (no fixed
  * offset; resolve it through an `Instant`).
  * @param {TimeScale} from
  * @param {TimeScale} to
@@ -16651,6 +17769,14 @@ function __wbg_get_imports() {
             const ret = LookAngles.__wrap(arg0);
             return ret;
         },
+        __wbg_moonelevationcrossing_new: function(arg0) {
+            const ret = MoonElevationCrossing.__wrap(arg0);
+            return ret;
+        },
+        __wbg_moontransit_new: function(arg0) {
+            const ret = MoonTransit.__wrap(arg0);
+            return ret;
+        },
         __wbg_movingbaselinesolution_new: function(arg0) {
             const ret = MovingBaselineSolution.__wrap(arg0);
             return ret;
@@ -16935,6 +18061,9 @@ const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
 const EphemerisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ephemeris_free(ptr, 1));
+const ErrorEllipse2Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_errorellipse2_free(ptr, 1));
 const FdeSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fdesolution_free(ptr, 1));
@@ -17013,6 +18142,12 @@ const LambertTransferFinalization = (typeof FinalizationRegistry === 'undefined'
 const LeapSecondTableFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_leapsecondtable_free(ptr, 1));
+const LeastSquaresDropOneReportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_leastsquaresdroponereport_free(ptr, 1));
+const LeastSquaresResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_leastsquaresresult_free(ptr, 1));
 const LinkBudgetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_linkbudget_free(ptr, 1));
@@ -17028,6 +18163,12 @@ const LookAnglesFinalization = (typeof FinalizationRegistry === 'undefined')
 const MappingFactorsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mappingfactors_free(ptr, 1));
+const MoonElevationCrossingFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_moonelevationcrossing_free(ptr, 1));
+const MoonTransitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_moontransit_free(ptr, 1));
 const MovingBaselineSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_movingbaselinesolution_free(ptr, 1));
@@ -17109,6 +18250,12 @@ const PppFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined
 const PppFloatSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pppfloatsolution_free(ptr, 1));
+const PreciseEphemerisSampleSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preciseephemerissamplesource_free(ptr, 1));
+const PredictBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_predictbatch_free(ptr, 1));
 const PredictedObservablesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_predictedobservables_free(ptr, 1));