@neilberkman/sidereon 0.32.0 → 0.33.1

package/pkg/sidereon.js

@@ -4729,6 +4729,218 @@ export class ErrorEllipse2 {
 }
 if (Symbol.dispose) ErrorEllipse2.prototype[Symbol.dispose] = ErrorEllipse2.prototype.free;
 
+/**
+ * Accepted boundary convention for a validated exact SP3 product.
+ * @enum {0 | 1}
+ */
+export const ExactSp3Coverage = Object.freeze({
+    /**
+     * The declared boundary is excluded (288 five-minute epochs in one day).
+     */
+    HalfOpen: 0, "0": "HalfOpen",
+    /**
+     * The declared boundary epoch is present (289 five-minute epochs).
+     */
+    Inclusive: 1, "1": "Inclusive",
+});
+
+/**
+ * Result of parsing and validating exact SP3 bytes in one core call.
+ */
+export class ExactSp3ParseResult {
+    static __wrap(ptr) {
+        const obj = Object.create(ExactSp3ParseResult.prototype);
+        obj.__wbg_ptr = ptr;
+        ExactSp3ParseResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExactSp3ParseResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_exactsp3parseresult_free(ptr, 0);
+    }
+    /**
+     * @returns {ExactSp3Coverage}
+     */
+    get coverage() {
+        const ret = wasm.exactsp3parseresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Return the validated parsed product.
+     * @returns {Sp3}
+     */
+    get product() {
+        const ret = wasm.exactsp3parseresult_product(this.__wbg_ptr);
+        return Sp3.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ExactSp3ParseResult.prototype[Symbol.dispose] = ExactSp3ParseResult.prototype.free;
+
+/**
+ * Source-independent exact SP3 content request.
+ */
+export class ExactSp3Request {
+    static __wrap(ptr) {
+        const obj = Object.create(ExactSp3Request.prototype);
+        obj.__wbg_ptr = ptr;
+        ExactSp3RequestFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExactSp3RequestFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_exactsp3request_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get day() {
+        const ret = wasm.exactsp3request_day(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get expectedAgency() {
+        const ret = wasm.exactsp3request_expectedAgency(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;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get formatVersion() {
+        const ret = wasm.exactsp3request_formatVersion(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;
+    }
+    /**
+     * Construct an exact request from a complete catalog product identity.
+     * @param {GnssProductIdentity} identity
+     * @returns {ExactSp3Request}
+     */
+    static fromIdentity(identity) {
+        _assertClass(identity, GnssProductIdentity);
+        const ret = wasm.exactsp3request_fromIdentity(identity.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ExactSp3Request.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get issue() {
+        const ret = wasm.exactsp3request_issue(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;
+    }
+    /**
+     * @returns {number}
+     */
+    get month() {
+        const ret = wasm.exactsp3request_month(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Construct an exact request from explicit catalog identity fields.
+     * @param {number} year
+     * @param {number} month
+     * @param {number} day
+     * @param {string} span
+     * @param {string} sample
+     * @param {string | null} [issue]
+     */
+    constructor(year, month, day, span, sample, issue) {
+        const ptr0 = passStringToWasm0(span, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sample, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(issue) ? 0 : passStringToWasm0(issue, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.exactsp3request_new(year, month, day, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        ExactSp3RequestFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Require a particular SP3 line-1 producing-agency code.
+     * @param {string} agency
+     */
+    requireAgency(agency) {
+        const ptr0 = passStringToWasm0(agency, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.exactsp3request_requireAgency(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get sample() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.exactsp3request_sample(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get span() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.exactsp3request_span(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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get year() {
+        const ret = wasm.exactsp3request_year(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ExactSp3Request.prototype[Symbol.dispose] = ExactSp3Request.prototype.free;
+
 /**
  * A fault-detection-and-exclusion result: the surviving solution, the excluded
  * satellites in exclusion order, and the number of exclusions performed.
@@ -16603,6 +16815,24 @@ export class Sp3 {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Epoch count declared by SP3 header line 1, independent of the parsed
+     * body count used by [`Sp3::epochCount`].
+     * @returns {number}
+     */
+    get declaredEpochCount() {
+        const ret = wasm.sp3_declaredEpochCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Start epoch declared by SP3 header line 1, in product-scale seconds
+     * since J2000. Missing or malformed legacy header fields return undefined.
+     * @returns {number | undefined}
+     */
+    get declaredStartJ2000Seconds() {
+        const ret = wasm.sp3_declaredStartJ2000Seconds(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
     /**
      * Compute DGNSS pseudorange corrections from a surveyed base station.
      *
@@ -22466,6 +22696,44 @@ export function defaultPair(system) {
     return ret === 0 ? undefined : CarrierPair.__wrap(ret);
 }
 
+/**
+ * Return the officially cataloged default sampling token for a product date.
+ *
+ * Unlike the legacy date-free default, this preserves historical cadence
+ * changes such as the GFZ rapid and ultra-rapid transitions. On ESA
+ * ultra-rapid's issue-level transition date this reports the `0000`/
+ * start-of-day default; [`productIdentity`](product_identity) also considers
+ * the requested issue.
+ * @param {string} center
+ * @param {string} family
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {string}
+ */
+export function defaultSampleForDate(center, family, year, month, day) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(center, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(family, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultSampleForDate(ptr0, len0, ptr1, len1, year, month, day);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Default scenario seed as a hexadecimal string.
  * @returns {string}
@@ -26497,6 +26765,23 @@ export function parseCdmXml(text) {
     return Cdm.__wrap(ret[0]);
 }
 
+/**
+ * Parse and exact-validate SP3 bytes, returning both product and coverage.
+ * @param {Uint8Array} bytes
+ * @param {ExactSp3Request} request
+ * @returns {ExactSp3ParseResult}
+ */
+export function parseExactSp3(bytes, request) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(request, ExactSp3Request);
+    const ret = wasm.parseExactSp3(ptr0, len0, request.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ExactSp3ParseResult.__wrap(ret[0]);
+}
+
 /**
  * Parse NAVCEN's GPS constellation status HTML into status rows.
  *
@@ -27155,7 +27440,8 @@ export function prepareIonosphereFreeRtkArc(epochs, wide_lane_cycles, config) {
 }
 
 /**
- * Resolve an exact catalog product independently from distributor.
+ * Resolve an exact catalog product independently from distributor. When the
+ * sample is omitted, ultra-rapid issue-level cadence transitions are applied.
  * @param {string} center
  * @param {string} family
  * @param {number} year
@@ -27181,6 +27467,38 @@ export function productIdentity(center, family, year, month, day, sample, issue)
     return GnssProductIdentity.__wrap(ret[0]);
 }
 
+/**
+ * Return the catalog solution class for one center/product family.
+ *
+ * This product-aware query distinguishes IGS combined final SP3 (`final`)
+ * from IGS broadcast navigation (`broadcast`).
+ * @param {string} center
+ * @param {string} family
+ * @returns {string}
+ */
+export function productSolutionClass(center, family) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(center, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(family, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.productSolutionClass(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Propagate a fleet of already-initialized [`Tle`]s over a shared epoch grid in
  * a single call: the batched form of [`Tle.propagate`].
@@ -29591,6 +29909,22 @@ export function validateAgainstSp3Ids(records, ids) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Validate an already parsed SP3 product against an exact request.
+ * @param {Sp3} product
+ * @param {ExactSp3Request} request
+ * @returns {ExactSp3Coverage}
+ */
+export function validateExactSp3(product, request) {
+    _assertClass(product, Sp3);
+    _assertClass(request, ExactSp3Request);
+    const ret = wasm.validateExactSp3(product.__wbg_ptr, request.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Blend a first good post-outage fix back over an outage span.
  * @param {any} states
@@ -30442,6 +30776,12 @@ const ErrorEllipseFinalization = (typeof FinalizationRegistry === 'undefined')
 const ErrorEllipse2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_errorellipse2_free(ptr, 1));
+const ExactSp3ParseResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_exactsp3parseresult_free(ptr, 1));
+const ExactSp3RequestFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_exactsp3request_free(ptr, 1));
 const FdeSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fdesolution_free(ptr, 1));