gnss-js 1.30.0 → 1.32.0

package/dist/index.d.cts

@@ -4,7 +4,7 @@ export { A as ARC_GAP_FACTOR, B as BAND_LABELS, a as BDS_SATELLITES, b as BdsSat
 export { Scale, getBdsTime, getDateFromBdsTime, getDateFromDayOfWeek, getDateFromDayOfYear, getDateFromGalTime, getDateFromGloN, getDateFromGpsData, getDateFromGpsTime, getDateFromHourCode, getDateFromJulianDate, getDateFromMJD, getDateFromMJD2000, getDateFromRINEX, getDateFromTai, getDateFromTimeOfDay, getDateFromTt, getDateFromUnixTime, getDateFromUtc, getDayOfWeek, getDayOfYear, getGalTime, getGloN4, getGloNA, getGpsLeap, getGpsTime, getHourCode, getHoursFromTimeDifference, getJulianDate, getLeap, getMJD, getMJD2000, getMinutesFromTimeDifference, getNtpTime, getRINEX, getSecondsFromTimeDifference, getTaiDate, getTimeDifference, getTimeDifferenceFromDays, getTimeDifferenceFromHours, getTimeDifferenceFromMinutes, getTimeDifferenceFromObject, getTimeDifferenceFromSeconds, getTimeOfDay, getTimeOfWeek, getTotalDaysFromTimeDifference, getTtDate, getUnixTime, getUtcDate, getWeekNumber, getWeekOfYear } from './time.cjs';
 export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, rad2deg, rhumbLine, vincenty } from './coordinates.cjs';
 export { c as clampUnit, e as ecefToGeodetic, g as geodeticToEcef, a as getAer, b as getEnuDifference } from './ecef-CF0uAysr.cjs';
-export { CompactEpoch, CrxField, DiffState, EMPTY_WARNINGS, Nav4Input, RinexWarning, RinexWarnings, WarningAccumulator, WarningSeverity, WriteCrxOptions, createGzipLineSink, crxDecompress, crxRepair, fmtD, fmtF, hdrLine, padL, padR, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob } from './rinex.cjs';
+export { BiasRecord, BiasSinex, CompactEpoch, CrxField, DiffState, EMPTY_WARNINGS, Nav4Input, RinexWarning, RinexWarnings, WarningAccumulator, WarningSeverity, WriteCrxOptions, biasMetres, createGzipLineSink, crxDecompress, crxRepair, findSatBias, fmtD, fmtF, hdrLine, padL, padR, parseBiasSinex, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob } from './rinex.cjs';
 export { E as EpochSummary, P as ParseOptions, R as RinexHeader, a as RinexResult, b as RinexStats, S as SYSTEM_ORDER, c as SatObsCallback, p as parseRinexStream, s as systemCmp, d as systemName } from './parser-JPjjFgeP.cjs';
 export { C as CnavEphemeris, E as Ephemeris, G as GlonassEphemeris, K as KeplerEphemeris, N as NavHeader, a as NavResult, R as RinexCnavEphemeris, p as parseNavFile } from './nav-DImXUdbp.cjs';
 export { C as ClkFile, I as IonexGrid, S as Sp3File, a as Sp3Sample, c as clkBias, p as parseClk, b as parseIonex, d as parseSp3, s as sp3Position } from './clk-DGVBGRzA.cjs';
@@ -17,7 +17,7 @@ export { TrimbleEpoch, TrimbleFrame, TrimbleMeasurement, TrimbleNavResult, Trimb
 export { BinexEpoch, BinexMeasurement, BinexParseResult, BinexRecord, binexCrc16, binexCrc32, binexCsum8, binexRecords, decodeBinexEph, getBnxi, parseBinex } from './binex.cjs';
 export { AllPositionsData, AlmanacPosition, DopValues, EpochSkyData, SatAzEl, SatPoint, SatPosition, VisibilityPass, VisibilityResult, almanacEpochMs, almanacSatPosition, computeAllPositions, computeDop, computeLiveSkyPositions, computeSatPosition, computeVisibility, computeVisibilityFromPositions, dopplerHz, ecefToAzEl, ephInfoToEphemeris, glonassAlmanacEpochMs, glonassAlmanacPosition, glonassPosition, keplerPosition, maskRadForAzimuth, navTimesFromEph, rangeRate, selectEphemeris } from './orbit.cjs';
 export { Helmert14, REFERENCE_FRAMES, ReferenceFrame, applyHelmert, dateToEpoch, transformFrame } from './frames.cjs';
-export { AntennaOffset, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, PppAntennaModel, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, buildPppAntenna, createPppCorrections, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch } from './positioning.cjs';
+export { AntennaOffset, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, PppAntennaModel, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength } from './positioning.cjs';
 export { NtripCaster, NtripConnectionInfo, NtripNetwork, NtripStream, NtripStreamConnection, NtripVersion, Sourcetable, SourcetableEntry, connectToMountpoint, fetchSourcetable, parseSourcetable } from './ntrip.cjs';
 export { CompleteSatSignal, CompleteSignalStats, CompletenessAccumulator, CompletenessResult, CycleSlipAccumulator, CycleSlipEvent, CycleSlipResult, CycleSlipSignalStats, IonoAccumulator, IonoDcbResult, IonoPoint, IonoRatePoint, IonoRateSeries, IonoResult, IonoSeries, MultipathAccumulator, MultipathPoint, MultipathResult, MultipathSeries, MultipathSignalStat, QualityResult, SatDcbMap, analyzeQuality, applyIonoDcb, computeIonoRate, detrendIonoArcs, parseSinexBiasDcb } from './analysis.cjs';
 export { AntennaEntry, AntexFile, FrequencyData, frequencyLabel, parseAntex } from './antex.cjs';

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { A as ARC_GAP_FACTOR, B as BAND_LABELS, a as BDS_SATELLITES, b as BdsSat
 export { Scale, getBdsTime, getDateFromBdsTime, getDateFromDayOfWeek, getDateFromDayOfYear, getDateFromGalTime, getDateFromGloN, getDateFromGpsData, getDateFromGpsTime, getDateFromHourCode, getDateFromJulianDate, getDateFromMJD, getDateFromMJD2000, getDateFromRINEX, getDateFromTai, getDateFromTimeOfDay, getDateFromTt, getDateFromUnixTime, getDateFromUtc, getDayOfWeek, getDayOfYear, getGalTime, getGloN4, getGloNA, getGpsLeap, getGpsTime, getHourCode, getHoursFromTimeDifference, getJulianDate, getLeap, getMJD, getMJD2000, getMinutesFromTimeDifference, getNtpTime, getRINEX, getSecondsFromTimeDifference, getTaiDate, getTimeDifference, getTimeDifferenceFromDays, getTimeDifferenceFromHours, getTimeDifferenceFromMinutes, getTimeDifferenceFromObject, getTimeDifferenceFromSeconds, getTimeOfDay, getTimeOfWeek, getTotalDaysFromTimeDifference, getTtDate, getUnixTime, getUtcDate, getWeekNumber, getWeekOfYear } from './time.js';
 export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, rad2deg, rhumbLine, vincenty } from './coordinates.js';
 export { c as clampUnit, e as ecefToGeodetic, g as geodeticToEcef, a as getAer, b as getEnuDifference } from './ecef-CF0uAysr.js';
-export { CompactEpoch, CrxField, DiffState, EMPTY_WARNINGS, Nav4Input, RinexWarning, RinexWarnings, WarningAccumulator, WarningSeverity, WriteCrxOptions, createGzipLineSink, crxDecompress, crxRepair, fmtD, fmtF, hdrLine, padL, padR, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob } from './rinex.js';
+export { BiasRecord, BiasSinex, CompactEpoch, CrxField, DiffState, EMPTY_WARNINGS, Nav4Input, RinexWarning, RinexWarnings, WarningAccumulator, WarningSeverity, WriteCrxOptions, biasMetres, createGzipLineSink, crxDecompress, crxRepair, findSatBias, fmtD, fmtF, hdrLine, padL, padR, parseBiasSinex, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob } from './rinex.js';
 export { E as EpochSummary, P as ParseOptions, R as RinexHeader, a as RinexResult, b as RinexStats, S as SYSTEM_ORDER, c as SatObsCallback, p as parseRinexStream, s as systemCmp, d as systemName } from './parser-JPjjFgeP.js';
 export { C as CnavEphemeris, E as Ephemeris, G as GlonassEphemeris, K as KeplerEphemeris, N as NavHeader, a as NavResult, R as RinexCnavEphemeris, p as parseNavFile } from './nav-DImXUdbp.js';
 export { C as ClkFile, I as IonexGrid, S as Sp3File, a as Sp3Sample, c as clkBias, p as parseClk, b as parseIonex, d as parseSp3, s as sp3Position } from './clk-DGVBGRzA.js';
@@ -17,7 +17,7 @@ export { TrimbleEpoch, TrimbleFrame, TrimbleMeasurement, TrimbleNavResult, Trimb
 export { BinexEpoch, BinexMeasurement, BinexParseResult, BinexRecord, binexCrc16, binexCrc32, binexCsum8, binexRecords, decodeBinexEph, getBnxi, parseBinex } from './binex.js';
 export { AllPositionsData, AlmanacPosition, DopValues, EpochSkyData, SatAzEl, SatPoint, SatPosition, VisibilityPass, VisibilityResult, almanacEpochMs, almanacSatPosition, computeAllPositions, computeDop, computeLiveSkyPositions, computeSatPosition, computeVisibility, computeVisibilityFromPositions, dopplerHz, ecefToAzEl, ephInfoToEphemeris, glonassAlmanacEpochMs, glonassAlmanacPosition, glonassPosition, keplerPosition, maskRadForAzimuth, navTimesFromEph, rangeRate, selectEphemeris } from './orbit.js';
 export { Helmert14, REFERENCE_FRAMES, ReferenceFrame, applyHelmert, dateToEpoch, transformFrame } from './frames.js';
-export { AntennaOffset, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, PppAntennaModel, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, buildPppAntenna, createPppCorrections, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch } from './positioning.js';
+export { AntennaOffset, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, PppAntennaModel, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength } from './positioning.js';
 export { NtripCaster, NtripConnectionInfo, NtripNetwork, NtripStream, NtripStreamConnection, NtripVersion, Sourcetable, SourcetableEntry, connectToMountpoint, fetchSourcetable, parseSourcetable } from './ntrip.js';
 export { CompleteSatSignal, CompleteSignalStats, CompletenessAccumulator, CompletenessResult, CycleSlipAccumulator, CycleSlipEvent, CycleSlipResult, CycleSlipSignalStats, IonoAccumulator, IonoDcbResult, IonoPoint, IonoRatePoint, IonoRateSeries, IonoResult, IonoSeries, MultipathAccumulator, MultipathPoint, MultipathResult, MultipathSeries, MultipathSignalStat, QualityResult, SatDcbMap, analyzeQuality, applyIonoDcb, computeIonoRate, detrendIonoArcs, parseSinexBiasDcb } from './analysis.js';
 export { AntennaEntry, AntexFile, FrequencyData, frequencyLabel, parseAntex } from './antex.js';

package/dist/index.js

@@ -146,6 +146,8 @@ import {
   RtkFloatEngine,
   buildPppAntenna,
   createPppCorrections,
+  estimateWidelaneFcb,
+  extractWidelaneArcs,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -155,14 +157,17 @@ import {
   lambdaSearch,
   moonEcef,
   niellMapping,
+  nlWavelength,
+  resolvePppAmbiguities,
   satClockCorrection,
   solidEarthTide,
   solveDgnss,
   solvePpp,
   solveSpp,
   sunEcef,
-  toRtkEpoch
-} from "./chunk-CRFFUU5Y.js";
+  toRtkEpoch,
+  wlWavelength
+} from "./chunk-HOH27N42.js";
 import {
   almanacEpochMs,
   almanacSatPosition,
@@ -201,12 +206,15 @@ import {
 import {
   EMPTY_WARNINGS,
   WarningAccumulator,
+  biasMetres,
   createGzipLineSink,
+  findSatBias,
   fmtD,
   fmtF,
   hdrLine,
   padL,
   padR,
+  parseBiasSinex,
   parseIonex,
   parseNavFile,
   stationHeaderLines,
@@ -217,7 +225,7 @@ import {
   writeRinexNav,
   writeRinexNav4,
   writeRinexObsBlob
-} from "./chunk-KDM2NVBO.js";
+} from "./chunk-5RNDQQ6J.js";
 import "./chunk-726LQBGM.js";
 import "./chunk-IQ5OIMQD.js";
 import {
@@ -428,6 +436,7 @@ export {
   analyzeQuality,
   applyHelmert,
   applyIonoDcb,
+  biasMetres,
   binexCrc16,
   binexCrc32,
   binexCsum8,
@@ -465,8 +474,11 @@ export {
   ecefToAzEl,
   ecefToGeodetic,
   ephInfoToEphemeris,
+  estimateWidelaneFcb,
   euclidean3D,
+  extractWidelaneArcs,
   fetchSourcetable,
+  findSatBias,
   fmtD,
   fmtF,
   formatUTCTime,
@@ -549,11 +561,13 @@ export {
   msmEpochToDate,
   navTimesFromEph,
   niellMapping,
+  nlWavelength,
   nmeaCoordToDecimal,
   oem4Frames,
   padL,
   padR,
   parseAntex,
+  parseBiasSinex,
   parseBinex,
   parseClk,
   parseCrxDataLine,
@@ -591,6 +605,7 @@ export {
   readString,
   reportDecodeError,
   resetGloFreqCache,
+  resolvePppAmbiguities,
   rhumbLine,
   rtcm3Constellation,
   satClockCorrection,
@@ -616,6 +631,7 @@ export {
   updateStreamStats,
   verifyChecksum,
   vincenty,
+  wlWavelength,
   writeCrx,
   writeModernObsBlob,
   writeRinex2ObsBlob,

package/dist/positioning.cjs

@@ -24,6 +24,8 @@ __export(positioning_exports, {
   RtkFloatEngine: () => RtkFloatEngine,
   buildPppAntenna: () => buildPppAntenna,
   createPppCorrections: () => createPppCorrections,
+  estimateWidelaneFcb: () => estimateWidelaneFcb,
+  extractWidelaneArcs: () => extractWidelaneArcs,
   gimSlantIonoDelayL1: () => gimSlantIonoDelayL1,
   gimVerticalTec: () => gimVerticalTec,
   gmst: () => gmst,
@@ -33,13 +35,16 @@ __export(positioning_exports, {
   lambdaSearch: () => lambdaSearch,
   moonEcef: () => moonEcef,
   niellMapping: () => niellMapping,
+  nlWavelength: () => nlWavelength,
+  resolvePppAmbiguities: () => resolvePppAmbiguities,
   satClockCorrection: () => satClockCorrection,
   solidEarthTide: () => solidEarthTide,
   solveDgnss: () => solveDgnss,
   solvePpp: () => solvePpp,
   solveSpp: () => solveSpp,
   sunEcef: () => sunEcef,
-  toRtkEpoch: () => toRtkEpoch
+  toRtkEpoch: () => toRtkEpoch,
+  wlWavelength: () => wlWavelength
 });
 module.exports = __toCommonJS(positioning_exports);
 
@@ -2430,6 +2435,212 @@ function solvePpp(epochs, sp3, opts) {
   };
 }
 
+// src/positioning/ppp-ar.ts
+function wlWavelength(f1, f2) {
+  return C_LIGHT / (f1 - f2);
+}
+function nlWavelength(f1, f2) {
+  return C_LIGHT / (f1 + f2);
+}
+function resolvePppAmbiguities(sats, Qaif, opts = {}) {
+  const wlThreshold = opts.wlThreshold ?? 0.25;
+  const ratioThreshold = opts.ratioThreshold ?? 3;
+  const kept = [];
+  const nWl = [];
+  const rejectedWl = [];
+  for (let i = 0; i < sats.length; i++) {
+    const s = sats[i];
+    const wlFloat = s.mwCyc - (s.wlBiasCyc ?? 0);
+    const r = Math.round(wlFloat);
+    if (Math.abs(wlFloat - r) <= wlThreshold) {
+      kept.push(i);
+      nWl.push(r);
+    } else {
+      rejectedWl.push(s.prn);
+    }
+  }
+  if (kept.length < 2) {
+    return {
+      fixed: false,
+      ratio: 0,
+      refPrn: null,
+      sats: [],
+      rejectedWl
+    };
+  }
+  const n1Float = [];
+  const lamNl = [];
+  for (let k = 0; k < kept.length; k++) {
+    const s = sats[kept[k]];
+    const lNl = nlWavelength(s.f1, s.f2);
+    lamNl.push(lNl);
+    const n1 = s.aIF / lNl - s.f2 / (s.f1 - s.f2) * nWl[k] - (s.nlBiasCyc ?? 0);
+    n1Float.push(n1);
+  }
+  let ref = 0;
+  for (let k = 1; k < kept.length; k++) {
+    const e = sats[kept[k]].elevDeg ?? -1;
+    if (e > (sats[kept[ref]].elevDeg ?? -1)) ref = k;
+  }
+  const m = kept.length - 1;
+  const sd = new Float64Array(m);
+  const Qsd = new Float64Array(m * m);
+  const others = [];
+  for (let k = 0; k < kept.length; k++) if (k !== ref) others.push(k);
+  const n = sats.length;
+  const qN1 = (ka, kb) => Qaif[kept[ka] * n + kept[kb]] / (lamNl[ka] * lamNl[kb]);
+  for (let a = 0; a < m; a++) {
+    const ka = others[a];
+    sd[a] = n1Float[ka] - n1Float[ref];
+    for (let b = 0; b < m; b++) {
+      const kb = others[b];
+      Qsd[a * m + b] = qN1(ka, kb) - qN1(ka, ref) - qN1(ref, kb) + qN1(ref, ref);
+    }
+  }
+  const res = lambdaSearch(sd, Qsd, m, 2);
+  const ratio = res ? Math.min(res.ratio, 999.9) : 0;
+  const fixed = !!res && ratio >= ratioThreshold;
+  const refN1 = Math.round(n1Float[ref]);
+  const sdFix = res?.candidates[0];
+  const outSats = [];
+  for (let k = 0; k < kept.length; k++) {
+    const s = sats[kept[k]];
+    let n1;
+    if (k === ref) {
+      n1 = refN1;
+    } else {
+      const a = others.indexOf(k);
+      n1 = fixed && sdFix ? refN1 + Math.round(sdFix[a]) : Math.round(n1Float[k]);
+    }
+    const lNl = lamNl[k];
+    const aIF = lNl * n1 + lNl * (s.f2 / (s.f1 - s.f2)) * nWl[k];
+    outSats.push({ prn: s.prn, nWl: nWl[k], n1, aIF });
+  }
+  return {
+    fixed,
+    ratio,
+    refPrn: sats[kept[ref]].prn,
+    sats: outSats,
+    rejectedWl
+  };
+}
+
+// src/positioning/ppp-fcb.ts
+function extractWidelaneArcs(station, epochs, opts = {}) {
+  const slipCyc = opts.slipCyc ?? 4;
+  const gapMs = opts.gapMs ?? 12e4;
+  const minObs = opts.minObs ?? 20;
+  const state = /* @__PURE__ */ new Map();
+  const out = [];
+  const flush = (prn) => {
+    const s = state.get(prn);
+    if (s && s.n >= minObs)
+      out.push({ station, prn, wlFloat: s.sum / s.n, nObs: s.n });
+  };
+  for (const ep of epochs) {
+    for (const o of ep.obs) {
+      if (!o.c1 || !o.c2 || !o.l1 || !o.l2) continue;
+      const lamW = C_LIGHT / (o.f1 - o.f2);
+      const codeNl = (o.f1 * o.c1 + o.f2 * o.c2) / (o.f1 + o.f2);
+      const mw = o.l1 - o.l2 - codeNl / lamW;
+      const s = state.get(o.prn);
+      if (!s || ep.timeMs - s.lastT > gapMs || Math.abs(mw - s.mean) > slipCyc) {
+        if (s) flush(o.prn);
+        state.set(o.prn, { sum: mw, n: 1, mean: mw, lastT: ep.timeMs });
+      } else {
+        s.sum += mw;
+        s.n += 1;
+        s.mean = s.sum / s.n;
+        s.lastT = ep.timeMs;
+      }
+    }
+  }
+  for (const prn of state.keys()) flush(prn);
+  return out;
+}
+function wrapHalf(x) {
+  return x - Math.round(x);
+}
+function circMean(vals, weights) {
+  let s = 0;
+  let c = 0;
+  for (let i = 0; i < vals.length; i++) {
+    const a = 2 * Math.PI * vals[i];
+    s += weights[i] * Math.sin(a);
+    c += weights[i] * Math.cos(a);
+  }
+  if (s === 0 && c === 0) return 0;
+  return wrapHalf(Math.atan2(s, c) / (2 * Math.PI));
+}
+function estimateWidelaneFcb(arcs, opts = {}) {
+  const maxIter = opts.maxIter ?? 50;
+  const tol = opts.tol ?? 1e-4;
+  const fixWindow = opts.fixWindow ?? 0.25;
+  const sats = [...new Set(arcs.map((a) => a.prn))].sort();
+  const stations = [...new Set(arcs.map((a) => a.station))].sort();
+  const refStation = stations[0] ?? "";
+  const satFcb = new Map(sats.map((s) => [s, 0]));
+  const rcvBias = new Map(stations.map((s) => [s, 0]));
+  const nInt = new Array(arcs.length).fill(0);
+  let iterations = 0;
+  for (let it = 0; it < maxIter; it++) {
+    iterations = it + 1;
+    for (let i = 0; i < arcs.length; i++) {
+      const a = arcs[i];
+      nInt[i] = Math.round(
+        a.wlFloat - rcvBias.get(a.station) - satFcb.get(a.prn)
+      );
+    }
+    let maxChange = 0;
+    for (const s of sats) {
+      const vals = [];
+      const w = [];
+      for (let i = 0; i < arcs.length; i++) {
+        const a = arcs[i];
+        if (a.prn !== s) continue;
+        vals.push(a.wlFloat - nInt[i] - rcvBias.get(a.station));
+        w.push(a.nObs);
+      }
+      if (!vals.length) continue;
+      const nv = circMean(vals, w);
+      maxChange = Math.max(maxChange, Math.abs(wrapHalf(nv - satFcb.get(s))));
+      satFcb.set(s, nv);
+    }
+    for (const r of stations) {
+      const vals = [];
+      const w = [];
+      for (let i = 0; i < arcs.length; i++) {
+        const a = arcs[i];
+        if (a.station !== r) continue;
+        vals.push(a.wlFloat - nInt[i] - satFcb.get(a.prn));
+        w.push(a.nObs);
+      }
+      if (!vals.length) continue;
+      rcvBias.set(r, circMean(vals, w));
+    }
+    const shift = rcvBias.get(refStation);
+    if (shift !== 0) {
+      for (const r of stations)
+        rcvBias.set(r, wrapHalf(rcvBias.get(r) - shift));
+      for (const s of sats) satFcb.set(s, wrapHalf(satFcb.get(s) + shift));
+    }
+    if (maxChange < tol) break;
+  }
+  let sumSq = 0;
+  let fixed = 0;
+  for (let i = 0; i < arcs.length; i++) {
+    const a = arcs[i];
+    const resid = wrapHalf(
+      a.wlFloat - nInt[i] - rcvBias.get(a.station) - satFcb.get(a.prn)
+    );
+    sumSq += resid * resid;
+    if (Math.abs(resid) <= fixWindow) fixed++;
+  }
+  const residRms = arcs.length ? Math.sqrt(sumSq / arcs.length) : 0;
+  const fixRate = arcs.length ? fixed / arcs.length : 0;
+  return { satFcb, rcvBias, residRms, fixRate, refStation, iterations };
+}
+
 // src/positioning/index.ts
 var GM_GPS2 = 3986005e8;
 var F_REL = -4442807633e-19;
@@ -2663,6 +2874,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   RtkFloatEngine,
   buildPppAntenna,
   createPppCorrections,
+  estimateWidelaneFcb,
+  extractWidelaneArcs,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -2672,11 +2885,14 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   lambdaSearch,
   moonEcef,
   niellMapping,
+  nlWavelength,
+  resolvePppAmbiguities,
   satClockCorrection,
   solidEarthTide,
   solveDgnss,
   solvePpp,
   solveSpp,
   sunEcef,
-  toRtkEpoch
+  toRtkEpoch,
+  wlWavelength
 });

package/dist/positioning.d.cts

@@ -714,6 +714,172 @@ declare function moonEcef(timeMs: number): [number, number, number];
  */
 declare function solidEarthTide(rcv: [number, number, number], sun: [number, number, number], moon: [number, number, number]): [number, number, number];
 
+/**
+ * PPP-AR — integer ambiguity resolution for Precise Point Positioning.
+ *
+ * Float PPP estimates one *ionosphere-free* ambiguity per satellite arc, a
+ * real number in metres. Fixing those to integers is what takes PPP from the
+ * decimetre to the centimetre level. The classic two-step decomposition is
+ * used here:
+ *
+ *   1. **Wide-lane** N_WL = N1 − N2 from the Melbourne–Wübbena combination.
+ *      The WL wavelength is ~86 cm (GPS), so the arc-averaged MW rounds to an
+ *      integer reliably once the satellite WL fractional-cycle bias is removed.
+ *   2. **Narrow-lane** N1, recovered from the float IF ambiguity with N_WL
+ *      fixed, then resolved with LAMBDA on *between-satellite single
+ *      differences* (which cancel the receiver phase bias) after removing the
+ *      satellite NL fractional-cycle bias.
+ *
+ * The satellite WL/NL fractional-cycle biases come from a phase-bias product
+ * (Bias-SINEX OSB from an AR-capable analysis centre such as CNES or CODE).
+ * Without them, a single receiver cannot separate the satellite bias from the
+ * integer, so those biases are required inputs — pass 0 only for a network
+ * datum where they have already been removed.
+ *
+ * The relation between the IF ambiguity (metres) and the integers is
+ *   A_IF = λ_NL·N1 + λ_NL·(f2/(f1−f2))·N_WL,   λ_NL = c/(f1+f2).
+ */
+/** Wide-lane wavelength c/(f1−f2) (m). */
+declare function wlWavelength(f1: number, f2: number): number;
+/** Narrow-lane wavelength c/(f1+f2) (m). */
+declare function nlWavelength(f1: number, f2: number): number;
+/** One satellite's float ambiguity inputs for AR. */
+interface ArSat {
+    prn: string;
+    /** Float ionosphere-free ambiguity (m) from the PPP EKF. */
+    aIF: number;
+    /** Arc-averaged Melbourne–Wübbena wide-lane estimate (cycles). */
+    mwCyc: number;
+    f1: number;
+    f2: number;
+    /** Satellite wide-lane fractional-cycle bias (cycles). Default 0. */
+    wlBiasCyc?: number;
+    /** Satellite narrow-lane fractional-cycle bias (cycles). Default 0. */
+    nlBiasCyc?: number;
+    /** Elevation (deg), used only to pick the reference satellite. */
+    elevDeg?: number;
+}
+interface ArOptions {
+    /** Max |MW − round| to accept a wide-lane (cycles). Default 0.25. */
+    wlThreshold?: number;
+    /** Min LAMBDA ratio to accept the narrow-lane fix. Default 3. */
+    ratioThreshold?: number;
+}
+interface ArFixedSat {
+    prn: string;
+    nWl: number;
+    n1: number;
+    /** Fixed IF ambiguity (m). */
+    aIF: number;
+}
+interface ArResult {
+    /** Whether the narrow-lane fix passed the ratio test. */
+    fixed: boolean;
+    /** LAMBDA ratio statistic (second-best / best). */
+    ratio: number;
+    /** Reference PRN whose absolute N1 stays float (SD datum). */
+    refPrn: string | null;
+    /** Fixed satellites (includes the reference with its float-rounded N1). */
+    sats: ArFixedSat[];
+    /** PRNs whose wide-lane did not round confidently (excluded). */
+    rejectedWl: string[];
+}
+/**
+ * Resolve PPP integer ambiguities from the float IF ambiguities and their
+ * covariance. `Qaif` is the n×n float covariance (m²) in the same order as
+ * `sats`. Returns the fixed narrow-lane / wide-lane integers and the ratio
+ * test result. A `fixed: false` result means the data did not support a
+ * confident fix (keep the float solution).
+ */
+declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
+
+/**
+ * Wide-lane fractional-cycle bias (FCB) estimation for PPP-AR — the
+ * self-contained route to integer ambiguities that needs no external
+ * phase-bias product, only a small network of stations.
+ *
+ * A single receiver cannot resolve ambiguities because its Melbourne–Wübbena
+ * wide-lane float is `Ñ_wl = N (integer) + b_rcv + b_sat`, and the integer
+ * and the satellite fractional bias `b_sat` are entangled. Across a *network*
+ * they separate: every station sees the same `b_sat` for a given satellite
+ * but its own integers and receiver bias, so the fractional part common to
+ * all stations *is* the satellite FCB. This is the classic Ge/Gendt method.
+ *
+ * The estimator alternates:
+ *   1. round each arc to its integer  N = round(Ñ_wl − b_rcv − b_sat);
+ *   2. update each satellite FCB      = circular-mean over stations of
+ *      (Ñ_wl − N − b_rcv);
+ *   3. update each receiver bias       = circular-mean over satellites of
+ *      (Ñ_wl − N − b_sat);
+ *   4. pin the datum (b_rcv of a reference station ≡ 0) — receiver and
+ *      satellite biases otherwise trade off by an arbitrary constant.
+ *
+ * The output `satFcb` feeds `resolvePppAmbiguities`' `wlBiasCyc`.
+ */
+/** Minimal per-satellite observation for wide-lane extraction. */
+interface WlObs {
+    prn: string;
+    f1: number;
+    f2: number;
+    /** Code on f1/f2 (m) and carrier phase on f1/f2 (cycles). */
+    c1: number;
+    c2: number;
+    l1: number;
+    l2: number;
+}
+/**
+ * Extract arc-averaged Melbourne–Wübbena wide-lanes for one station from its
+ * epoch stream. The MW combination
+ *   MW = (L1 − L2) − [(f1·C1 + f2·C2)/(f1+f2)] / (c/(f1−f2))   [cycles]
+ * is geometry-, clock- and (first-order) ionosphere-free, so it holds the
+ * wide-lane ambiguity plus biases and is near-constant within an arc. Arcs
+ * are split on a running-mean jump (cycle slip) or a time gap.
+ */
+declare function extractWidelaneArcs(station: string, epochs: {
+    timeMs: number;
+    obs: WlObs[];
+}[], opts?: {
+    slipCyc?: number;
+    gapMs?: number;
+    minObs?: number;
+}): WlArc[];
+/** One continuous wide-lane arc at a station. */
+interface WlArc {
+    station: string;
+    prn: string;
+    /** Arc-averaged Melbourne–Wübbena wide-lane float (cycles). */
+    wlFloat: number;
+    /** Number of epochs averaged (used as the weight). */
+    nObs: number;
+}
+interface WlFcbOptions {
+    /** Max iterations. Default 50. */
+    maxIter?: number;
+    /** Convergence threshold on the largest bias change (cycles). Default 1e-4. */
+    tol?: number;
+    /** Fix-rate acceptance window |resid| (cycles). Default 0.25. */
+    fixWindow?: number;
+}
+interface WlFcbResult {
+    /** Per-satellite wide-lane FCB (cycles, wrapped to [−0.5, 0.5)). */
+    satFcb: Map<string, number>;
+    /** Per-station wide-lane bias (cycles); the reference station is 0. */
+    rcvBias: Map<string, number>;
+    /** RMS of the post-fit arc residuals Ñ_wl − N − b_rcv − b_sat (cycles). */
+    residRms: number;
+    /** Fraction of arcs whose residual lies within `fixWindow` of an integer. */
+    fixRate: number;
+    /** Reference station pinning the datum. */
+    refStation: string;
+    iterations: number;
+}
+/**
+ * Estimate per-satellite wide-lane FCBs from a network of stations' arc
+ * wide-lane floats. Needs ≥2 stations sharing satellites to break the
+ * integer/bias entanglement.
+ */
+declare function estimateWidelaneFcb(arcs: WlArc[], opts?: WlFcbOptions): WlFcbResult;
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -803,4 +969,4 @@ declare function ionoFree(p1: number, p2: number, f1: number, f2: number): numbe
  */
 declare function solveSpp(pseudoranges: Map<string, number>, ephemerides: Map<string, Ephemeris>, timeMs: number, opts?: SppOptions): SppSolution | null;
 
-export { type AntennaOffset, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type PppAntennaModel, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppOptions, type PppSatObs, type PppSolution, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SatGeom, type SppOptions, type SppSolution, type TropoMapping, buildPppAntenna, createPppCorrections, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch };
+export { type AntennaOffset, type ArFixedSat, type ArOptions, type ArResult, type ArSat, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type PppAntennaModel, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppOptions, type PppSatObs, type PppSolution, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SatGeom, type SppOptions, type SppSolution, type TropoMapping, type WlArc, type WlFcbOptions, type WlFcbResult, type WlObs, buildPppAntenna, createPppCorrections, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };