@neilberkman/sidereon 0.39.0 → 1.0.0

package/pkg-node/sidereon.d.ts

@@ -56,6 +56,57 @@ export interface Sp3MergeIdentityOptions {
     systems?: string[];
     assertedFrameLabelSets?: string[][];
     helmert?: boolean;
+    verifyContinuity?: Sp3ContinuityOptions | null;
+}
+
+export type Sp3MergeOptions = Sp3MergeIdentityOptions;
+
+export interface Sp3ContinuityOptions {
+    orbitClass?: "meo_gnss" | "geosynchronous" | "leo" | null;
+    residualToleranceM?: number | null;
+}
+
+export interface ContinuityDefect {
+    kind: "duplicate_epoch" | "single_sample_series" | "speed_bound" | "hold_out_residual";
+    satellite: string;
+    fromJ2000S: number | undefined;
+    toJ2000S: number | undefined;
+    magnitude: number | undefined;
+    bound: number | undefined;
+}
+
+export interface ContinuityReport {
+    attested: boolean;
+    defects: ContinuityDefect[];
+    pairsChecked: number;
+    residualsChecked: number;
+    residualsSkipped: number;
+}
+
+export interface MergeContinuityViolation {
+    defect: ContinuityDefect;
+    fromSources: number[];
+    toSources: number[];
+    crossesContributors: boolean;
+}
+
+export interface WindowContinuityVerdict {
+    decision: "accept" | "refuse";
+    accepted: boolean;
+    influencingDefects: ContinuityDefect[];
+    influencingSplices: MergeContinuityViolation[];
+    allDefects: ContinuityDefect[];
+    allSplices: MergeContinuityViolation[];
+}
+
+export interface NominalCoverageInterval {
+    from: Date;
+    until: Date;
+}
+
+export interface NominalCoverage {
+    observed: NominalCoverageInterval | null;
+    predicted: NominalCoverageInterval | null;
 }
 
 export interface SurfaceMetInput {
@@ -2476,6 +2527,22 @@ export class ErrorEllipse2 {
     readonly semiMinor: number;
 }
 
+/**
+ * Stateful adapter around the core's target-neutral single-flight waiter.
+ */
+export class ExactCacheSingleFlightWait {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Start one bounded wait at a browser-monotonic timestamp in milliseconds.
+     */
+    constructor(started_ms: number, poll_interval_ms: number, heartbeat_interval_ms: number, liveness_timeout_ms: number, wait_timeout_ms: number);
+    /**
+     * Observe an opaque IndexedDB owner/heartbeat revision.
+     */
+    observe(now_ms: number, revision: Uint8Array): any;
+}
+
 /**
  * Accepted boundary convention for a validated exact SP3 product.
  */
@@ -4493,6 +4560,31 @@ export class NmeaParseResult {
     readonly sentences: any;
 }
 
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Nominal observed and predicted half-open coverage intervals.
+     */
+    readonly covers: NominalCoverage;
+    /**
+     * Nominal publication deadline as a UTC JavaScript `Date`.
+     */
+    readonly dueAt: Date;
+    /**
+     * Exact product identity expected at the due time.
+     */
+    readonly identity: GnssProductIdentity;
+}
+
 /**
  * Sans-IO NTRIP client state machine.
  */
@@ -7189,7 +7281,7 @@ export class Sp3 {
      * residualsSkipped }`. Reports rather than refuses: whether a product with
      * defects is acceptable is the caller's decision.
      */
-    checkContinuity(orbit_class?: string | null, residual_tolerance_m?: number | null): any;
+    checkContinuity(orbitClass?: string | null, residualToleranceM?: number | null): ContinuityReport;
     /**
      * Estimate `other`'s per-epoch common clock offset relative to this product.
      *
@@ -7199,6 +7291,16 @@ export class Sp3 {
      * `sidereon_core::ephemeris::clock_reference_offset`.
      */
     clockReferenceOffset(other: Sp3, min_common?: number | null): Sp3ClockReferenceOffset[];
+    /**
+     * 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.
+     */
+    continuityVerdict(fromJ2000S: number, throughJ2000S: number, orbitClass?: string | null, residualToleranceM?: number | null): WindowContinuityVerdict;
     /**
      * Compute DGNSS pseudorange corrections from a surveyed base station.
      *
@@ -7338,6 +7440,13 @@ export class Sp3 {
      * `TypeError` if the satellite has no record there.
      */
     state(satellite: string, epoch_index: number): Sp3State;
+    /**
+     * 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.
+     */
+    stencilExtent(): { beforeS: number; afterS: number };
     /**
      * Serialize to standard SP3 text (the version named by the header, `c` or
      * `d`). Deterministic: the same product always produces byte-identical text.
@@ -7618,6 +7727,14 @@ export class Sp3MergeReport {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    continuityVerdict(merged: Sp3, fromJ2000S: number, throughJ2000S: number): WindowContinuityVerdict | null;
     /**
      * Per-(epoch, satellite) agreement statistics for every accepted cell, in
      * output (epoch, then satellite) order, one entry per cell written to the
@@ -10707,7 +10824,7 @@ export function mergeNavcenAt(records: any, assessments: any): any;
  * empty source list or bad options, and an `Error` for incompatible inputs
  * (mismatched time systems or coordinate frames).
  */
-export function mergeSp3(sources: Sp3[], options: any): Sp3MergeResult;
+export function mergeSp3(sources: Sp3[], options?: Sp3MergeOptions | null): Sp3MergeResult;
 
 export function meridianTransits(body: string, station: any, start_unix_us: bigint, end_unix_us: bigint, step_s: number, tolerance_s: number): any;
 
@@ -10855,6 +10972,14 @@ export function networkField(input: any): any;
  */
 export function newestPublishedProduct(center: string, family: string, listing_body: string): any;
 
+/**
+ * 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.
+ */
+export function nextIssueDue(center: string, content: string, now: Date): NominalIssue;
+
 /**
  * Scalar normalized innovation squared statistic.
  */

package/pkg-node/sidereon.js

@@ -4785,6 +4785,56 @@ class ErrorEllipse2 {
 if (Symbol.dispose) ErrorEllipse2.prototype[Symbol.dispose] = ErrorEllipse2.prototype.free;
 exports.ErrorEllipse2 = ErrorEllipse2;
 
+/**
+ * Stateful adapter around the core's target-neutral single-flight waiter.
+ */
+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;
+exports.ExactCacheSingleFlightWait = ExactCacheSingleFlightWait;
+
 /**
  * Accepted boundary convention for a validated exact SP3 product.
  * @enum {0 | 1}
@@ -10005,6 +10055,58 @@ class NmeaParseResult {
 if (Symbol.dispose) NmeaParseResult.prototype[Symbol.dispose] = NmeaParseResult.prototype.free;
 exports.NmeaParseResult = NmeaParseResult;
 
+/**
+ * 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.
+ */
+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;
+exports.NominalIssue = NominalIssue;
+
 /**
  * Sans-IO NTRIP client state machine.
  */
@@ -17199,6 +17301,27 @@ 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`].
@@ -17550,6 +17673,20 @@ 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.
@@ -18226,6 +18363,25 @@ 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}
      */
@@ -26997,6 +27153,29 @@ function newestPublishedProduct(center, family, listing_body) {
 }
 exports.newestPublishedProduct = newestPublishedProduct;
 
+/**
+ * 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}
+ */
+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]);
+}
+exports.nextIssueDue = nextIssueDue;
+
 /**
  * Scalar normalized innovation squared statistic.
  * @param {number} innovation
@@ -31438,6 +31617,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;
@@ -31598,6 +31805,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;
@@ -31930,6 +32141,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));
@@ -32089,6 +32303,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));