@neilberkman/sidereon 0.9.1 → 0.9.2

package/pkg/sidereon.js

@@ -9126,6 +9126,58 @@ export class PppFloatSolution {
 }
 if (Symbol.dispose) PppFloatSolution.prototype[Symbol.dispose] = PppFloatSolution.prototype.free;
 
+/**
+ * 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 PreciseEphemerisSampleSource {
+    static __wrap(ptr) {
+        const obj = Object.create(PreciseEphemerisSampleSource.prototype);
+        obj.__wbg_ptr = ptr;
+        PreciseEphemerisSampleSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreciseEphemerisSampleSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        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
@@ -10728,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[]}
@@ -15967,6 +16038,27 @@ 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
@@ -16909,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
@@ -18135,6 +18250,9 @@ 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));