@neilberkman/sidereon 0.39.1 → 1.0.1

package/pkg/sidereon.js

@@ -4729,6 +4729,55 @@ export class ErrorEllipse2 {
 }
 if (Symbol.dispose) ErrorEllipse2.prototype[Symbol.dispose] = ErrorEllipse2.prototype.free;
 
+/**
+ * Stateful adapter around the core's target-neutral single-flight waiter.
+ */
+export class ExactCacheSingleFlightWait {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExactCacheSingleFlightWaitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_exactcachesingleflightwait_free(ptr, 0);
+    }
+    /**
+     * Start one bounded wait at a browser-monotonic timestamp in milliseconds.
+     * @param {number} started_ms
+     * @param {number} poll_interval_ms
+     * @param {number} heartbeat_interval_ms
+     * @param {number} liveness_timeout_ms
+     * @param {number} wait_timeout_ms
+     */
+    constructor(started_ms, poll_interval_ms, heartbeat_interval_ms, liveness_timeout_ms, wait_timeout_ms) {
+        const ret = wasm.exactcachesingleflightwait_new(started_ms, poll_interval_ms, heartbeat_interval_ms, liveness_timeout_ms, wait_timeout_ms);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        ExactCacheSingleFlightWaitFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Observe an opaque IndexedDB owner/heartbeat revision.
+     * @param {number} now_ms
+     * @param {Uint8Array} revision
+     * @returns {any}
+     */
+    observe(now_ms, revision) {
+        const ptr0 = passArray8ToWasm0(revision, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.exactcachesingleflightwait_observe(this.__wbg_ptr, now_ms, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) ExactCacheSingleFlightWait.prototype[Symbol.dispose] = ExactCacheSingleFlightWait.prototype.free;
+
 /**
  * Accepted boundary convention for a validated exact SP3 product.
  * @enum {0 | 1}
@@ -9889,6 +9938,57 @@ export class NmeaParseResult {
 }
 if (Symbol.dispose) NmeaParseResult.prototype[Symbol.dispose] = NmeaParseResult.prototype.free;
 
+/**
+ * The next catalog issue nominally due at or after a UTC instant.
+ *
+ * This is a network-free schedule query. It does not claim the archive has
+ * published the issue. Coverage intervals are half-open and all returned
+ * `Date` values are UTC instants.
+ */
+export class NominalIssue {
+    static __wrap(ptr) {
+        const obj = Object.create(NominalIssue.prototype);
+        obj.__wbg_ptr = ptr;
+        NominalIssueFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NominalIssueFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_nominalissue_free(ptr, 0);
+    }
+    /**
+     * Nominal observed and predicted half-open coverage intervals.
+     * @returns {any}
+     */
+    get covers() {
+        const ret = wasm.nominalissue_covers(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Nominal publication deadline as a UTC JavaScript `Date`.
+     * @returns {Date}
+     */
+    get dueAt() {
+        const ret = wasm.nominalissue_dueAt(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Exact product identity expected at the due time.
+     * @returns {GnssProductIdentity}
+     */
+    get identity() {
+        const ret = wasm.nominalissue_identity(this.__wbg_ptr);
+        return GnssProductIdentity.__wrap(ret);
+    }
+}
+if (Symbol.dispose) NominalIssue.prototype[Symbol.dispose] = NominalIssue.prototype.free;
+
 /**
  * Sans-IO NTRIP client state machine.
  */
@@ -17008,6 +17108,27 @@ export class Sp3 {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Decide whether product-wide continuity findings can influence an
+     * inclusive evaluation window through this product's interpolation
+     * stencil.
+     *
+     * Omitted options use the existing defaults (`"meo_gnss"` and 1 metre).
+     * Passing `null` disables the corresponding check. The returned object
+     * retains both the influencing findings and the complete report.
+     * @param {number} from_j2000_s
+     * @param {number} through_j2000_s
+     * @param {any} orbit_class
+     * @param {any} residual_tolerance_m
+     * @returns {any}
+     */
+    continuityVerdict(from_j2000_s, through_j2000_s, orbit_class, residual_tolerance_m) {
+        const ret = wasm.sp3_continuityVerdict(this.__wbg_ptr, from_j2000_s, through_j2000_s, orbit_class, residual_tolerance_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Epoch count declared by SP3 header line 1, independent of the parsed
      * body count used by [`Sp3::epochCount`].
@@ -17359,6 +17480,20 @@ export class Sp3 {
         }
         return Sp3State.__wrap(ret[0]);
     }
+    /**
+     * Time reach of the SP3 position interpolator before and after a query.
+     *
+     * The core derives both values from this product's declared epoch interval
+     * and interpolation-node count. Callers never supply a stencil duration.
+     * @returns {any}
+     */
+    stencilExtent() {
+        const ret = wasm.sp3_stencilExtent(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Serialize to standard SP3 text (the version named by the header, `c` or
      * `d`). Deterministic: the same product always produces byte-identical text.
@@ -18027,6 +18162,25 @@ export class Sp3MergeReport {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Decide whether this merge's optional continuity post-condition can
+     * influence an inclusive evaluation window through `merged`'s derived
+     * interpolation stencil.
+     *
+     * Returns `null` when `verifyContinuity` was not requested for the merge.
+     * @param {Sp3} merged
+     * @param {number} from_j2000_s
+     * @param {number} through_j2000_s
+     * @returns {any}
+     */
+    continuityVerdict(merged, from_j2000_s, through_j2000_s) {
+        _assertClass(merged, Sp3);
+        const ret = wasm.sp3mergereport_continuityVerdict(this.__wbg_ptr, merged.__wbg_ptr, from_j2000_s, through_j2000_s);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {number}
      */
@@ -26504,6 +26658,28 @@ export function newestPublishedProduct(center, family, listing_body) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Return the next catalog issue nominally due at or after `now`.
+ *
+ * Fractional milliseconds advance to the next whole second, matching the
+ * core catalog's whole-second resolution.
+ * @param {string} center
+ * @param {string} content
+ * @param {Date} now
+ * @returns {NominalIssue}
+ */
+export function nextIssueDue(center, content, now) {
+    const ptr0 = passStringToWasm0(center, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nextIssueDue(ptr0, len0, ptr1, len1, now);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return NominalIssue.__wrap(ret[0]);
+}
+
 /**
  * Scalar normalized innovation squared statistic.
  * @param {number} innovation
@@ -30730,6 +30906,34 @@ function __wbg_get_imports() {
             const ret = Array.from(arg0);
             return ret;
         },
+        __wbg_getTime_d6f070c088c9b5ed: function(arg0) {
+            const ret = arg0.getTime();
+            return ret;
+        },
+        __wbg_getUTCDate_652a2ad7beebbadf: function(arg0) {
+            const ret = arg0.getUTCDate();
+            return ret;
+        },
+        __wbg_getUTCFullYear_5af8ca4e2020c06e: function(arg0) {
+            const ret = arg0.getUTCFullYear();
+            return ret;
+        },
+        __wbg_getUTCHours_3f030631d89309ea: function(arg0) {
+            const ret = arg0.getUTCHours();
+            return ret;
+        },
+        __wbg_getUTCMinutes_03f5d6c64c8b2fb1: function(arg0) {
+            const ret = arg0.getUTCMinutes();
+            return ret;
+        },
+        __wbg_getUTCMonth_773ed3c34515d086: function(arg0) {
+            const ret = arg0.getUTCMonth();
+            return ret;
+        },
+        __wbg_getUTCSeconds_92d08d3589a8958a: function(arg0) {
+            const ret = arg0.getUTCSeconds();
+            return ret;
+        },
         __wbg_get_507a50627bffa49b: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -30890,6 +31094,10 @@ function __wbg_get_imports() {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
+        __wbg_new_cc984128914cfc6f: function(arg0) {
+            const ret = new Date(arg0);
+            return ret;
+        },
         __wbg_new_cd45aabdf6073e84: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
@@ -31222,6 +31430,9 @@ const ErrorEllipseFinalization = (typeof FinalizationRegistry === 'undefined')
 const ErrorEllipse2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_errorellipse2_free(ptr, 1));
+const ExactCacheSingleFlightWaitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_exactcachesingleflightwait_free(ptr, 1));
 const ExactSp3ParseResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_exactsp3parseresult_free(ptr, 1));
@@ -31381,6 +31592,9 @@ const NmeaAccumulatorFinalization = (typeof FinalizationRegistry === 'undefined'
 const NmeaParseResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_nmeaparseresult_free(ptr, 1));
+const NominalIssueFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nominalissue_free(ptr, 1));
 const NtripClientMachineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ntripclientmachine_free(ptr, 1));