gnss-js 1.54.0 → 1.56.0

package/dist/analysis.cjs

@@ -557,21 +557,23 @@ var CycleSlipAccumulator = class {
           dualChecked.add(b2);
         }
       }
-      for (const [band, lm] of phaseM) {
-        if (dualChecked.has(band)) continue;
-        const prevLm = prev.phase.get(band);
-        if (prevLm === void 0) continue;
-        const cm = codeM.get(band);
-        const prevCm = prev.code.get(band);
-        if (cm === void 0 || prevCm === void 0) continue;
-        const dPhase = lm - prevLm;
-        const dCode = cm - prevCm;
-        const jumpM = Math.abs(dPhase - dCode);
-        const lbl = BAND_LABELS[sys]?.[band] ?? band;
-        const sigKey = `${sys}:${lbl}`;
-        this.countEpoch(sigKey);
-        if (jumpM > SF_THRESHOLD_M) {
-          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+      if (sys !== "S") {
+        for (const [band, lm] of phaseM) {
+          if (dualChecked.has(band)) continue;
+          const prevLm = prev.phase.get(band);
+          if (prevLm === void 0) continue;
+          const cm = codeM.get(band);
+          const prevCm = prev.code.get(band);
+          if (cm === void 0 || prevCm === void 0) continue;
+          const dPhase = lm - prevLm;
+          const dCode = cm - prevCm;
+          const jumpM = Math.abs(dPhase - dCode);
+          const lbl = BAND_LABELS[sys]?.[band] ?? band;
+          const sigKey = `${sys}:${lbl}`;
+          this.countEpoch(sigKey);
+          if (jumpM > SF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+          }
         }
       }
     }

package/dist/analysis.js

@@ -8,7 +8,7 @@ import {
   computeIonoRate,
   detrendIonoArcs,
   parseSinexBiasDcb
-} from "./chunk-Z5UZUNCB.js";
+} from "./chunk-KUSUN7DP.js";
 import "./chunk-3U5AX7PY.js";
 import "./chunk-FIEWO4J4.js";
 export {

package/dist/{chunk-U32IU7RO.js → chunk-BU6YC6VK.js}

@@ -1551,6 +1551,36 @@ var SbasProcessor = class {
     }
     return n;
   }
+  /**
+   * Correction-coverage census at a GPS week/time — a diagnostic funnel over
+   * the current state, explaining how many masked satellites are actually
+   * correctable. Each stage subsumes the requirement of the previous one for a
+   * full range/clock correction: a satellite is `corrected` only when it has
+   * both a fresh fast correction and (for non-SBAS satellites) a fresh
+   * long-term correction (exactly {@link satCorrection}'s gate). `ionoGrid` is
+   * the total number of valid grid points — the additional requirement for the
+   * *iono*-corrected subset a solver forms per pierce point.
+   *
+   * Use it to tell "no corrections applied" (mask empty / products stale) apart
+   * from "corrections applied but the pierce points aren't grid-covered yet".
+   */
+  coverage(week, tow) {
+    const now = gpsSeconds(week, tow);
+    let masked = 0;
+    let fast = 0;
+    let long = 0;
+    let corrected = 0;
+    for (const s of this.sats) {
+      if (!s.prn) continue;
+      masked++;
+      if (s.fcorr && s.fcorr.t0s !== 0 && s.fcorr.udre < 15 && Math.abs(now - s.fcorr.t0s + this.tlat) <= MAXSBSAGEF)
+        fast++;
+      if (s.prn[0] === "S" || s.lcorr && s.lcorr.t0s !== 0 && Math.abs(now - s.lcorr.t0s) <= MAXSBSAGEL)
+        long++;
+      if (this.satCorrection(s.prn, week, tow)) corrected++;
+    }
+    return { masked, fast, long, corrected, ionoGrid: this.ionoGridPoints() };
+  }
   /**
    * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
    * no valid (unexpired) long-term + fast correction is available. Add `dPos`

package/dist/{chunk-Z5UZUNCB.js → chunk-KUSUN7DP.js}

@@ -352,21 +352,23 @@ var CycleSlipAccumulator = class {
           dualChecked.add(b2);
         }
       }
-      for (const [band, lm] of phaseM) {
-        if (dualChecked.has(band)) continue;
-        const prevLm = prev.phase.get(band);
-        if (prevLm === void 0) continue;
-        const cm = codeM.get(band);
-        const prevCm = prev.code.get(band);
-        if (cm === void 0 || prevCm === void 0) continue;
-        const dPhase = lm - prevLm;
-        const dCode = cm - prevCm;
-        const jumpM = Math.abs(dPhase - dCode);
-        const lbl = BAND_LABELS[sys]?.[band] ?? band;
-        const sigKey = `${sys}:${lbl}`;
-        this.countEpoch(sigKey);
-        if (jumpM > SF_THRESHOLD_M) {
-          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+      if (sys !== "S") {
+        for (const [band, lm] of phaseM) {
+          if (dualChecked.has(band)) continue;
+          const prevLm = prev.phase.get(band);
+          if (prevLm === void 0) continue;
+          const cm = codeM.get(band);
+          const prevCm = prev.code.get(band);
+          if (cm === void 0 || prevCm === void 0) continue;
+          const dPhase = lm - prevLm;
+          const dCode = cm - prevCm;
+          const jumpM = Math.abs(dPhase - dCode);
+          const lbl = BAND_LABELS[sys]?.[band] ?? band;
+          const sigKey = `${sys}:${lbl}`;
+          this.countEpoch(sigKey);
+          if (jumpM > SF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+          }
         }
       }
     }

package/dist/index.cjs

@@ -13637,6 +13637,36 @@ var SbasProcessor = class {
     }
     return n;
   }
+  /**
+   * Correction-coverage census at a GPS week/time — a diagnostic funnel over
+   * the current state, explaining how many masked satellites are actually
+   * correctable. Each stage subsumes the requirement of the previous one for a
+   * full range/clock correction: a satellite is `corrected` only when it has
+   * both a fresh fast correction and (for non-SBAS satellites) a fresh
+   * long-term correction (exactly {@link satCorrection}'s gate). `ionoGrid` is
+   * the total number of valid grid points — the additional requirement for the
+   * *iono*-corrected subset a solver forms per pierce point.
+   *
+   * Use it to tell "no corrections applied" (mask empty / products stale) apart
+   * from "corrections applied but the pierce points aren't grid-covered yet".
+   */
+  coverage(week, tow) {
+    const now = gpsSeconds(week, tow);
+    let masked = 0;
+    let fast = 0;
+    let long = 0;
+    let corrected = 0;
+    for (const s of this.sats) {
+      if (!s.prn) continue;
+      masked++;
+      if (s.fcorr && s.fcorr.t0s !== 0 && s.fcorr.udre < 15 && Math.abs(now - s.fcorr.t0s + this.tlat) <= MAXSBSAGEF)
+        fast++;
+      if (s.prn[0] === "S" || s.lcorr && s.lcorr.t0s !== 0 && Math.abs(now - s.lcorr.t0s) <= MAXSBSAGEL)
+        long++;
+      if (this.satCorrection(s.prn, week, tow)) corrected++;
+    }
+    return { masked, fast, long, corrected, ionoGrid: this.ionoGridPoints() };
+  }
   /**
    * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
    * no valid (unexpired) long-term + fast correction is available. Add `dPos`
@@ -15913,21 +15943,23 @@ var CycleSlipAccumulator = class {
           dualChecked.add(b2);
         }
       }
-      for (const [band, lm] of phaseM) {
-        if (dualChecked.has(band)) continue;
-        const prevLm = prev.phase.get(band);
-        if (prevLm === void 0) continue;
-        const cm = codeM.get(band);
-        const prevCm = prev.code.get(band);
-        if (cm === void 0 || prevCm === void 0) continue;
-        const dPhase = lm - prevLm;
-        const dCode = cm - prevCm;
-        const jumpM = Math.abs(dPhase - dCode);
-        const lbl = BAND_LABELS[sys]?.[band] ?? band;
-        const sigKey = `${sys}:${lbl}`;
-        this.countEpoch(sigKey);
-        if (jumpM > SF_THRESHOLD_M) {
-          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+      if (sys !== "S") {
+        for (const [band, lm] of phaseM) {
+          if (dualChecked.has(band)) continue;
+          const prevLm = prev.phase.get(band);
+          if (prevLm === void 0) continue;
+          const cm = codeM.get(band);
+          const prevCm = prev.code.get(band);
+          if (cm === void 0 || prevCm === void 0) continue;
+          const dPhase = lm - prevLm;
+          const dCode = cm - prevCm;
+          const jumpM = Math.abs(dPhase - dCode);
+          const lbl = BAND_LABELS[sys]?.[band] ?? band;
+          const sigKey = `${sys}:${lbl}`;
+          this.countEpoch(sigKey);
+          if (jumpM > SF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+          }
         }
       }
     }

package/dist/index.js

@@ -109,7 +109,7 @@ import {
   computeIonoRate,
   detrendIonoArcs,
   parseSinexBiasDcb
-} from "./chunk-Z5UZUNCB.js";
+} from "./chunk-KUSUN7DP.js";
 import {
   Scale,
   getDateFromDayOfWeek,
@@ -168,7 +168,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-U32IU7RO.js";
+} from "./chunk-BU6YC6VK.js";
 import "./chunk-WQX354KD.js";
 import {
   almanacEpochMs,

package/dist/positioning.cjs

@@ -2025,6 +2025,36 @@ var SbasProcessor = class {
     }
     return n;
   }
+  /**
+   * Correction-coverage census at a GPS week/time — a diagnostic funnel over
+   * the current state, explaining how many masked satellites are actually
+   * correctable. Each stage subsumes the requirement of the previous one for a
+   * full range/clock correction: a satellite is `corrected` only when it has
+   * both a fresh fast correction and (for non-SBAS satellites) a fresh
+   * long-term correction (exactly {@link satCorrection}'s gate). `ionoGrid` is
+   * the total number of valid grid points — the additional requirement for the
+   * *iono*-corrected subset a solver forms per pierce point.
+   *
+   * Use it to tell "no corrections applied" (mask empty / products stale) apart
+   * from "corrections applied but the pierce points aren't grid-covered yet".
+   */
+  coverage(week, tow) {
+    const now = gpsSeconds(week, tow);
+    let masked = 0;
+    let fast = 0;
+    let long = 0;
+    let corrected = 0;
+    for (const s of this.sats) {
+      if (!s.prn) continue;
+      masked++;
+      if (s.fcorr && s.fcorr.t0s !== 0 && s.fcorr.udre < 15 && Math.abs(now - s.fcorr.t0s + this.tlat) <= MAXSBSAGEF)
+        fast++;
+      if (s.prn[0] === "S" || s.lcorr && s.lcorr.t0s !== 0 && Math.abs(now - s.lcorr.t0s) <= MAXSBSAGEL)
+        long++;
+      if (this.satCorrection(s.prn, week, tow)) corrected++;
+    }
+    return { masked, fast, long, corrected, ionoGrid: this.ionoGridPoints() };
+  }
   /**
    * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
    * no valid (unexpired) long-term + fast correction is available. Add `dPos`

package/dist/positioning.d.cts

@@ -598,6 +598,26 @@ declare class SbasProcessor {
     activeSats(): string[];
     /** Number of ionospheric grid points with a valid delay across all bands. */
     ionoGridPoints(): number;
+    /**
+     * Correction-coverage census at a GPS week/time — a diagnostic funnel over
+     * the current state, explaining how many masked satellites are actually
+     * correctable. Each stage subsumes the requirement of the previous one for a
+     * full range/clock correction: a satellite is `corrected` only when it has
+     * both a fresh fast correction and (for non-SBAS satellites) a fresh
+     * long-term correction (exactly {@link satCorrection}'s gate). `ionoGrid` is
+     * the total number of valid grid points — the additional requirement for the
+     * *iono*-corrected subset a solver forms per pierce point.
+     *
+     * Use it to tell "no corrections applied" (mask empty / products stale) apart
+     * from "corrections applied but the pierce points aren't grid-covered yet".
+     */
+    coverage(week: number, tow: number): {
+        masked: number;
+        fast: number;
+        long: number;
+        corrected: number;
+        ionoGrid: number;
+    };
     /**
      * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
      * no valid (unexpired) long-term + fast correction is available. Add `dPos`

package/dist/positioning.d.ts

@@ -598,6 +598,26 @@ declare class SbasProcessor {
     activeSats(): string[];
     /** Number of ionospheric grid points with a valid delay across all bands. */
     ionoGridPoints(): number;
+    /**
+     * Correction-coverage census at a GPS week/time — a diagnostic funnel over
+     * the current state, explaining how many masked satellites are actually
+     * correctable. Each stage subsumes the requirement of the previous one for a
+     * full range/clock correction: a satellite is `corrected` only when it has
+     * both a fresh fast correction and (for non-SBAS satellites) a fresh
+     * long-term correction (exactly {@link satCorrection}'s gate). `ionoGrid` is
+     * the total number of valid grid points — the additional requirement for the
+     * *iono*-corrected subset a solver forms per pierce point.
+     *
+     * Use it to tell "no corrections applied" (mask empty / products stale) apart
+     * from "corrections applied but the pierce points aren't grid-covered yet".
+     */
+    coverage(week: number, tow: number): {
+        masked: number;
+        fast: number;
+        long: number;
+        corrected: number;
+        ionoGrid: number;
+    };
     /**
      * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
      * no valid (unexpired) long-term + fast correction is available. Add `dPos`

package/dist/positioning.js

@@ -30,7 +30,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-U32IU7RO.js";
+} from "./chunk-BU6YC6VK.js";
 import "./chunk-WQX354KD.js";
 import "./chunk-MHGNKSSH.js";
 import "./chunk-MIIM4LDY.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnss-js",
-  "version": "1.54.0",
+  "version": "1.56.0",
   "description": "Comprehensive GNSS library for JavaScript — time scales, coordinates, RINEX parsing, RTCM3 decoding, orbit computation, and signal analysis",
   "type": "module",
   "sideEffects": false,