gnss-js 1.34.0 → 1.36.0

package/dist/{chunk-H73PZB5C.js → chunk-3FG4XVCB.js}

@@ -1959,6 +1959,28 @@ function solvePpp(epochs, sp3, opts) {
       phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
     });
   }
+  let finalState;
+  if (opts.exposeState) {
+    const ambs = [];
+    for (const [prn, index] of ambIdx) {
+      const s = arcSnap.get(prn);
+      if (!s || s.nEpochs < 10) continue;
+      ambs.push({
+        prn,
+        index,
+        aIF: x[index],
+        mwCyc: mwState.get(prn)?.mean ?? s.mwCyc,
+        f1: s.f1,
+        f2: s.f2,
+        elevDeg: s.elevSum / s.nEpochs
+      });
+    }
+    finalState = {
+      position: [x[IDX_X], x[IDX_Y], x[IDX_Z]],
+      covariance: P.map((row) => row.slice()),
+      ambiguities: ambs
+    };
+  }
   for (const prn of [...arcSnap.keys()]) flushArc(prn);
   const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
   const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
@@ -1975,7 +1997,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -2068,6 +2091,117 @@ function resolvePppAmbiguities(sats, Qaif, opts = {}) {
     rejectedWl
   };
 }
+function solveSpd(A, b) {
+  const n = b.length;
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let s = A[i][j];
+      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (s <= 0) return null;
+        L[i][j] = Math.sqrt(s);
+      } else {
+        L[i][j] = s / L[j][j];
+      }
+    }
+  }
+  const y = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i][k] * y[k];
+    y[i] = s / L[i][i];
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let s = y[i];
+    for (let k = i + 1; k < n; k++) s -= L[k][i] * x[k];
+    x[i] = s / L[i][i];
+  }
+  return x;
+}
+function fixPppPosition(state, fcb, opts = {}) {
+  const floatPos = state.position;
+  const noFix = {
+    fixed: false,
+    position: floatPos,
+    floatPosition: floatPos,
+    shift: [0, 0, 0],
+    nFixed: 0,
+    ratio: 0,
+    refPrn: null
+  };
+  const amb = state.ambiguities;
+  if (amb.length < 3) return noFix;
+  const sats = amb.map((a) => ({
+    prn: a.prn,
+    aIF: a.aIF,
+    mwCyc: a.mwCyc,
+    f1: a.f1,
+    f2: a.f2,
+    wlBiasCyc: fcb.satWlFcb.get(a.prn) ?? 0,
+    nlBiasCyc: fcb.satNlFcb.get(a.prn) ?? 0,
+    elevDeg: a.elevDeg
+  }));
+  const n = sats.length;
+  const Qaif = new Float64Array(n * n);
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < n; j++)
+      Qaif[i * n + j] = state.covariance[amb[i].index][amb[j].index];
+  const res = resolvePppAmbiguities(sats, Qaif, opts);
+  if (!res.fixed || res.refPrn === null) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const idxOfPrn = new Map(amb.map((a) => [a.prn, a.index]));
+  const floatOfPrn = new Map(amb.map((a) => [a.prn, a.aIF]));
+  const kept = res.sats.filter((s) => idxOfPrn.has(s.prn));
+  const refPos = kept.findIndex((s) => s.prn === res.refPrn);
+  if (refPos < 0 || kept.length < 2) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const ambIdx = kept.map((s) => idxOfPrn.get(s.prn));
+  const aFloat = kept.map((s) => floatOfPrn.get(s.prn));
+  const aFixed = kept.map((s) => s.aIF);
+  const others = kept.map((_, i) => i).filter((i) => i !== refPos);
+  const m = others.length;
+  const P = state.covariance;
+  const qAA = (i, j) => P[ambIdx[i]][ambIdx[j]];
+  const qXA = (r, i) => P[r][ambIdx[i]];
+  const Qzz = Array.from({ length: m }, () => new Array(m).fill(0));
+  const z = new Array(m).fill(0);
+  for (let a = 0; a < m; a++) {
+    const ia = others[a];
+    z[a] = aFloat[ia] - aFloat[refPos] - (aFixed[ia] - aFixed[refPos]);
+    for (let b = 0; b < m; b++) {
+      const ib = others[b];
+      Qzz[a][b] = qAA(ia, ib) - qAA(ia, refPos) - qAA(refPos, ib) + qAA(refPos, refPos);
+    }
+  }
+  const Qxz = [0, 1, 2].map(
+    (r) => others.map((ia) => qXA(r, ia) - qXA(r, refPos))
+  );
+  const y = solveSpd(Qzz, z);
+  if (!y) return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  const shift = [0, 0, 0];
+  for (let r = 0; r < 3; r++) {
+    let s = 0;
+    for (let a = 0; a < m; a++) s += Qxz[r][a] * y[a];
+    shift[r] = -s;
+  }
+  return {
+    fixed: true,
+    position: [
+      floatPos[0] + shift[0],
+      floatPos[1] + shift[1],
+      floatPos[2] + shift[2]
+    ],
+    floatPosition: floatPos,
+    shift,
+    nFixed: m,
+    ratio: res.ratio,
+    refPrn: res.refPrn
+  };
+}
 
 // src/positioning/ppp-fcb.ts
 function extractWidelaneArcs(station, epochs, opts = {}) {
@@ -2221,6 +2355,39 @@ function estimateNarrowlaneFcb(arcs, wl, opts = {}) {
   const res = decomposeFcb(entries, { fixWindow: 0.15, ...opts });
   return { ...res, usedArcs: entries.length, wlRejected };
 }
+function estimateNetworkFcbs(arcs, opts = {}) {
+  const minArcEpochs = opts.minArcEpochs ?? 120;
+  const minWlObs = opts.minWlObs ?? 40;
+  const fixWindow = opts.fixWindow ?? 0.15;
+  const satWlFcb = /* @__PURE__ */ new Map();
+  const satNlFcb = /* @__PURE__ */ new Map();
+  const perSystem = {};
+  const systems = [...new Set(arcs.map((a) => a.prn[0]))].sort();
+  for (const sys of systems) {
+    const sysArcs = arcs.filter((a) => a.prn[0] === sys);
+    const wlArcs = sysArcs.filter((a) => a.nEpochs >= minWlObs).map((a) => ({
+      station: a.station,
+      prn: a.prn,
+      wlFloat: a.mwCyc,
+      nObs: a.nEpochs
+    }));
+    if (wlArcs.length < 3) continue;
+    const wl = estimateWidelaneFcb(wlArcs, { fixWindow });
+    const nlInput = sysArcs.filter((a) => a.nEpochs >= minArcEpochs);
+    const nl = estimateNarrowlaneFcb(nlInput, wl, { fixWindow });
+    for (const [prn, v] of wl.satFcb) satWlFcb.set(prn, v);
+    for (const [prn, v] of nl.satFcb) satNlFcb.set(prn, v);
+    perSystem[sys] = {
+      wlFixRate: wl.fixRate,
+      wlResidRms: wl.residRms,
+      nlUsedArcs: nl.usedArcs,
+      nlFixRate: nl.fixRate,
+      nlResidRms: nl.residRms,
+      wlRejected: nl.wlRejected
+    };
+  }
+  return { satWlFcb, satNlFcb, perSystem };
+}
 
 // src/positioning/index.ts
 var GM_GPS = 3986005e8;
@@ -2471,9 +2638,11 @@ export {
   wlWavelength,
   nlWavelength,
   resolvePppAmbiguities,
+  fixPppPosition,
   extractWidelaneArcs,
   estimateWidelaneFcb,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   satClockCorrection,
   ionoFree,
   solveSpp

package/dist/index.cjs

@@ -150,11 +150,13 @@ __export(src_exports, {
   ecefToGeodetic: () => ecefToGeodetic,
   ephInfoToEphemeris: () => ephInfoToEphemeris,
   estimateNarrowlaneFcb: () => estimateNarrowlaneFcb,
+  estimateNetworkFcbs: () => estimateNetworkFcbs,
   estimateWidelaneFcb: () => estimateWidelaneFcb,
   euclidean3D: () => euclidean3D,
   extractWidelaneArcs: () => extractWidelaneArcs,
   fetchSourcetable: () => fetchSourcetable,
   findSatBias: () => findSatBias,
+  fixPppPosition: () => fixPppPosition,
   fmtD: () => fmtD,
   fmtF: () => fmtF,
   formatUTCTime: () => formatUTCTime,
@@ -13356,6 +13358,28 @@ function solvePpp(epochs, sp3, opts) {
       phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
     });
   }
+  let finalState;
+  if (opts.exposeState) {
+    const ambs = [];
+    for (const [prn, index] of ambIdx) {
+      const s = arcSnap.get(prn);
+      if (!s || s.nEpochs < 10) continue;
+      ambs.push({
+        prn,
+        index,
+        aIF: x[index],
+        mwCyc: mwState.get(prn)?.mean ?? s.mwCyc,
+        f1: s.f1,
+        f2: s.f2,
+        elevDeg: s.elevSum / s.nEpochs
+      });
+    }
+    finalState = {
+      position: [x[IDX_X], x[IDX_Y], x[IDX_Z]],
+      covariance: P.map((row) => row.slice()),
+      ambiguities: ambs
+    };
+  }
   for (const prn of [...arcSnap.keys()]) flushArc(prn);
   const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
   const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
@@ -13372,7 +13396,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -13465,6 +13490,117 @@ function resolvePppAmbiguities(sats, Qaif, opts = {}) {
     rejectedWl
   };
 }
+function solveSpd(A, b) {
+  const n = b.length;
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let s = A[i][j];
+      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (s <= 0) return null;
+        L[i][j] = Math.sqrt(s);
+      } else {
+        L[i][j] = s / L[j][j];
+      }
+    }
+  }
+  const y = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i][k] * y[k];
+    y[i] = s / L[i][i];
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let s = y[i];
+    for (let k = i + 1; k < n; k++) s -= L[k][i] * x[k];
+    x[i] = s / L[i][i];
+  }
+  return x;
+}
+function fixPppPosition(state, fcb, opts = {}) {
+  const floatPos = state.position;
+  const noFix = {
+    fixed: false,
+    position: floatPos,
+    floatPosition: floatPos,
+    shift: [0, 0, 0],
+    nFixed: 0,
+    ratio: 0,
+    refPrn: null
+  };
+  const amb = state.ambiguities;
+  if (amb.length < 3) return noFix;
+  const sats = amb.map((a) => ({
+    prn: a.prn,
+    aIF: a.aIF,
+    mwCyc: a.mwCyc,
+    f1: a.f1,
+    f2: a.f2,
+    wlBiasCyc: fcb.satWlFcb.get(a.prn) ?? 0,
+    nlBiasCyc: fcb.satNlFcb.get(a.prn) ?? 0,
+    elevDeg: a.elevDeg
+  }));
+  const n = sats.length;
+  const Qaif = new Float64Array(n * n);
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < n; j++)
+      Qaif[i * n + j] = state.covariance[amb[i].index][amb[j].index];
+  const res = resolvePppAmbiguities(sats, Qaif, opts);
+  if (!res.fixed || res.refPrn === null) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const idxOfPrn = new Map(amb.map((a) => [a.prn, a.index]));
+  const floatOfPrn = new Map(amb.map((a) => [a.prn, a.aIF]));
+  const kept = res.sats.filter((s) => idxOfPrn.has(s.prn));
+  const refPos = kept.findIndex((s) => s.prn === res.refPrn);
+  if (refPos < 0 || kept.length < 2) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const ambIdx = kept.map((s) => idxOfPrn.get(s.prn));
+  const aFloat = kept.map((s) => floatOfPrn.get(s.prn));
+  const aFixed = kept.map((s) => s.aIF);
+  const others = kept.map((_, i) => i).filter((i) => i !== refPos);
+  const m = others.length;
+  const P = state.covariance;
+  const qAA = (i, j) => P[ambIdx[i]][ambIdx[j]];
+  const qXA = (r, i) => P[r][ambIdx[i]];
+  const Qzz = Array.from({ length: m }, () => new Array(m).fill(0));
+  const z = new Array(m).fill(0);
+  for (let a = 0; a < m; a++) {
+    const ia = others[a];
+    z[a] = aFloat[ia] - aFloat[refPos] - (aFixed[ia] - aFixed[refPos]);
+    for (let b = 0; b < m; b++) {
+      const ib = others[b];
+      Qzz[a][b] = qAA(ia, ib) - qAA(ia, refPos) - qAA(refPos, ib) + qAA(refPos, refPos);
+    }
+  }
+  const Qxz = [0, 1, 2].map(
+    (r) => others.map((ia) => qXA(r, ia) - qXA(r, refPos))
+  );
+  const y = solveSpd(Qzz, z);
+  if (!y) return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  const shift = [0, 0, 0];
+  for (let r = 0; r < 3; r++) {
+    let s = 0;
+    for (let a = 0; a < m; a++) s += Qxz[r][a] * y[a];
+    shift[r] = -s;
+  }
+  return {
+    fixed: true,
+    position: [
+      floatPos[0] + shift[0],
+      floatPos[1] + shift[1],
+      floatPos[2] + shift[2]
+    ],
+    floatPosition: floatPos,
+    shift,
+    nFixed: m,
+    ratio: res.ratio,
+    refPrn: res.refPrn
+  };
+}
 
 // src/positioning/ppp-fcb.ts
 function extractWidelaneArcs(station, epochs, opts = {}) {
@@ -13618,6 +13754,39 @@ function estimateNarrowlaneFcb(arcs, wl, opts = {}) {
   const res = decomposeFcb(entries, { fixWindow: 0.15, ...opts });
   return { ...res, usedArcs: entries.length, wlRejected };
 }
+function estimateNetworkFcbs(arcs, opts = {}) {
+  const minArcEpochs = opts.minArcEpochs ?? 120;
+  const minWlObs = opts.minWlObs ?? 40;
+  const fixWindow = opts.fixWindow ?? 0.15;
+  const satWlFcb = /* @__PURE__ */ new Map();
+  const satNlFcb = /* @__PURE__ */ new Map();
+  const perSystem = {};
+  const systems = [...new Set(arcs.map((a) => a.prn[0]))].sort();
+  for (const sys of systems) {
+    const sysArcs = arcs.filter((a) => a.prn[0] === sys);
+    const wlArcs = sysArcs.filter((a) => a.nEpochs >= minWlObs).map((a) => ({
+      station: a.station,
+      prn: a.prn,
+      wlFloat: a.mwCyc,
+      nObs: a.nEpochs
+    }));
+    if (wlArcs.length < 3) continue;
+    const wl = estimateWidelaneFcb(wlArcs, { fixWindow });
+    const nlInput = sysArcs.filter((a) => a.nEpochs >= minArcEpochs);
+    const nl = estimateNarrowlaneFcb(nlInput, wl, { fixWindow });
+    for (const [prn, v] of wl.satFcb) satWlFcb.set(prn, v);
+    for (const [prn, v] of nl.satFcb) satNlFcb.set(prn, v);
+    perSystem[sys] = {
+      wlFixRate: wl.fixRate,
+      wlResidRms: wl.residRms,
+      nlUsedArcs: nl.usedArcs,
+      nlFixRate: nl.fixRate,
+      nlResidRms: nl.residRms,
+      wlRejected: nl.wlRejected
+    };
+  }
+  return { satWlFcb, satNlFcb, perSystem };
+}
 
 // src/positioning/index.ts
 var GM_GPS3 = 3986005e8;
@@ -16237,11 +16406,13 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   ecefToGeodetic,
   ephInfoToEphemeris,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   euclidean3D,
   extractWidelaneArcs,
   fetchSourcetable,
   findSatBias,
+  fixPppPosition,
   fmtD,
   fmtF,
   formatUTCTime,

package/dist/index.d.cts

@@ -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, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, NlArc, NlFcbResult, PppAntennaModel, PppArc, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateNarrowlaneFcb, 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 { AntennaOffset, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, FixedPositionResult, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, NetworkFcbResult, NetworkFcbSummary, NlArc, NlFcbResult, PppAntennaModel, PppArc, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppFixState, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateNarrowlaneFcb, estimateNetworkFcbs, estimateWidelaneFcb, extractWidelaneArcs, fixPppPosition, 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

@@ -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, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, NlArc, NlFcbResult, PppAntennaModel, PppArc, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateNarrowlaneFcb, 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 { AntennaOffset, ArFixedSat, ArOptions, ArResult, ArSat, CorrectionResult, DgnssOptions, DgnssSolution, EphemerisSource, FixedPositionResult, IONO_L1_M_PER_TECU, KlobucharCoeffs, LambdaResult, NetworkFcbResult, NetworkFcbSummary, NlArc, NlFcbResult, PppAntennaModel, PppArc, PppCorrectionConfig, PppCorrections, PppEpoch, PppEpochContext, PppEpochResult, PppFixState, PppOptions, PppSatObs, PppSolution, RawObservation, RtkEpochMeasurements, RtkFloatEngine, RtkFloatOptions, RtkFloatSolution, RtkMeasurement, SatGeom, SppOptions, SppSolution, TropoMapping, WlArc, WlFcbOptions, WlFcbResult, WlObs, buildPppAntenna, createPppCorrections, estimateNarrowlaneFcb, estimateNetworkFcbs, estimateWidelaneFcb, extractWidelaneArcs, fixPppPosition, 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

@@ -147,8 +147,10 @@ import {
   buildPppAntenna,
   createPppCorrections,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -168,7 +170,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-H73PZB5C.js";
+} from "./chunk-3FG4XVCB.js";
 import {
   almanacEpochMs,
   almanacSatPosition,
@@ -476,11 +478,13 @@ export {
   ecefToGeodetic,
   ephInfoToEphemeris,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   euclidean3D,
   extractWidelaneArcs,
   fetchSourcetable,
   findSatBias,
+  fixPppPosition,
   fmtD,
   fmtF,
   formatUTCTime,

package/dist/positioning.cjs

@@ -25,8 +25,10 @@ __export(positioning_exports, {
   buildPppAntenna: () => buildPppAntenna,
   createPppCorrections: () => createPppCorrections,
   estimateNarrowlaneFcb: () => estimateNarrowlaneFcb,
+  estimateNetworkFcbs: () => estimateNetworkFcbs,
   estimateWidelaneFcb: () => estimateWidelaneFcb,
   extractWidelaneArcs: () => extractWidelaneArcs,
+  fixPppPosition: () => fixPppPosition,
   gimSlantIonoDelayL1: () => gimSlantIonoDelayL1,
   gimVerticalTec: () => gimVerticalTec,
   gmst: () => gmst,
@@ -2484,6 +2486,28 @@ function solvePpp(epochs, sp3, opts) {
       phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
     });
   }
+  let finalState;
+  if (opts.exposeState) {
+    const ambs = [];
+    for (const [prn, index] of ambIdx) {
+      const s = arcSnap.get(prn);
+      if (!s || s.nEpochs < 10) continue;
+      ambs.push({
+        prn,
+        index,
+        aIF: x[index],
+        mwCyc: mwState.get(prn)?.mean ?? s.mwCyc,
+        f1: s.f1,
+        f2: s.f2,
+        elevDeg: s.elevSum / s.nEpochs
+      });
+    }
+    finalState = {
+      position: [x[IDX_X], x[IDX_Y], x[IDX_Z]],
+      covariance: P.map((row) => row.slice()),
+      ambiguities: ambs
+    };
+  }
   for (const prn of [...arcSnap.keys()]) flushArc(prn);
   const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
   const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
@@ -2500,7 +2524,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -2593,6 +2618,117 @@ function resolvePppAmbiguities(sats, Qaif, opts = {}) {
     rejectedWl
   };
 }
+function solveSpd(A, b) {
+  const n = b.length;
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let s = A[i][j];
+      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (s <= 0) return null;
+        L[i][j] = Math.sqrt(s);
+      } else {
+        L[i][j] = s / L[j][j];
+      }
+    }
+  }
+  const y = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i][k] * y[k];
+    y[i] = s / L[i][i];
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let s = y[i];
+    for (let k = i + 1; k < n; k++) s -= L[k][i] * x[k];
+    x[i] = s / L[i][i];
+  }
+  return x;
+}
+function fixPppPosition(state, fcb, opts = {}) {
+  const floatPos = state.position;
+  const noFix = {
+    fixed: false,
+    position: floatPos,
+    floatPosition: floatPos,
+    shift: [0, 0, 0],
+    nFixed: 0,
+    ratio: 0,
+    refPrn: null
+  };
+  const amb = state.ambiguities;
+  if (amb.length < 3) return noFix;
+  const sats = amb.map((a) => ({
+    prn: a.prn,
+    aIF: a.aIF,
+    mwCyc: a.mwCyc,
+    f1: a.f1,
+    f2: a.f2,
+    wlBiasCyc: fcb.satWlFcb.get(a.prn) ?? 0,
+    nlBiasCyc: fcb.satNlFcb.get(a.prn) ?? 0,
+    elevDeg: a.elevDeg
+  }));
+  const n = sats.length;
+  const Qaif = new Float64Array(n * n);
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < n; j++)
+      Qaif[i * n + j] = state.covariance[amb[i].index][amb[j].index];
+  const res = resolvePppAmbiguities(sats, Qaif, opts);
+  if (!res.fixed || res.refPrn === null) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const idxOfPrn = new Map(amb.map((a) => [a.prn, a.index]));
+  const floatOfPrn = new Map(amb.map((a) => [a.prn, a.aIF]));
+  const kept = res.sats.filter((s) => idxOfPrn.has(s.prn));
+  const refPos = kept.findIndex((s) => s.prn === res.refPrn);
+  if (refPos < 0 || kept.length < 2) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const ambIdx = kept.map((s) => idxOfPrn.get(s.prn));
+  const aFloat = kept.map((s) => floatOfPrn.get(s.prn));
+  const aFixed = kept.map((s) => s.aIF);
+  const others = kept.map((_, i) => i).filter((i) => i !== refPos);
+  const m = others.length;
+  const P = state.covariance;
+  const qAA = (i, j) => P[ambIdx[i]][ambIdx[j]];
+  const qXA = (r, i) => P[r][ambIdx[i]];
+  const Qzz = Array.from({ length: m }, () => new Array(m).fill(0));
+  const z = new Array(m).fill(0);
+  for (let a = 0; a < m; a++) {
+    const ia = others[a];
+    z[a] = aFloat[ia] - aFloat[refPos] - (aFixed[ia] - aFixed[refPos]);
+    for (let b = 0; b < m; b++) {
+      const ib = others[b];
+      Qzz[a][b] = qAA(ia, ib) - qAA(ia, refPos) - qAA(refPos, ib) + qAA(refPos, refPos);
+    }
+  }
+  const Qxz = [0, 1, 2].map(
+    (r) => others.map((ia) => qXA(r, ia) - qXA(r, refPos))
+  );
+  const y = solveSpd(Qzz, z);
+  if (!y) return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  const shift = [0, 0, 0];
+  for (let r = 0; r < 3; r++) {
+    let s = 0;
+    for (let a = 0; a < m; a++) s += Qxz[r][a] * y[a];
+    shift[r] = -s;
+  }
+  return {
+    fixed: true,
+    position: [
+      floatPos[0] + shift[0],
+      floatPos[1] + shift[1],
+      floatPos[2] + shift[2]
+    ],
+    floatPosition: floatPos,
+    shift,
+    nFixed: m,
+    ratio: res.ratio,
+    refPrn: res.refPrn
+  };
+}
 
 // src/positioning/ppp-fcb.ts
 function extractWidelaneArcs(station, epochs, opts = {}) {
@@ -2746,6 +2882,39 @@ function estimateNarrowlaneFcb(arcs, wl, opts = {}) {
   const res = decomposeFcb(entries, { fixWindow: 0.15, ...opts });
   return { ...res, usedArcs: entries.length, wlRejected };
 }
+function estimateNetworkFcbs(arcs, opts = {}) {
+  const minArcEpochs = opts.minArcEpochs ?? 120;
+  const minWlObs = opts.minWlObs ?? 40;
+  const fixWindow = opts.fixWindow ?? 0.15;
+  const satWlFcb = /* @__PURE__ */ new Map();
+  const satNlFcb = /* @__PURE__ */ new Map();
+  const perSystem = {};
+  const systems = [...new Set(arcs.map((a) => a.prn[0]))].sort();
+  for (const sys of systems) {
+    const sysArcs = arcs.filter((a) => a.prn[0] === sys);
+    const wlArcs = sysArcs.filter((a) => a.nEpochs >= minWlObs).map((a) => ({
+      station: a.station,
+      prn: a.prn,
+      wlFloat: a.mwCyc,
+      nObs: a.nEpochs
+    }));
+    if (wlArcs.length < 3) continue;
+    const wl = estimateWidelaneFcb(wlArcs, { fixWindow });
+    const nlInput = sysArcs.filter((a) => a.nEpochs >= minArcEpochs);
+    const nl = estimateNarrowlaneFcb(nlInput, wl, { fixWindow });
+    for (const [prn, v] of wl.satFcb) satWlFcb.set(prn, v);
+    for (const [prn, v] of nl.satFcb) satNlFcb.set(prn, v);
+    perSystem[sys] = {
+      wlFixRate: wl.fixRate,
+      wlResidRms: wl.residRms,
+      nlUsedArcs: nl.usedArcs,
+      nlFixRate: nl.fixRate,
+      nlResidRms: nl.residRms,
+      wlRejected: nl.wlRejected
+    };
+  }
+  return { satWlFcb, satNlFcb, perSystem };
+}
 
 // src/positioning/index.ts
 var GM_GPS2 = 3986005e8;
@@ -2981,8 +3150,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   buildPppAntenna,
   createPppCorrections,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,

package/dist/positioning.d.cts

@@ -631,6 +631,9 @@ interface PppOptions {
     ztdProcessNoise?: number;
     /** Model + estimate the troposphere. Default true. */
     troposphere?: boolean;
+    /** Expose the final EKF state (position + ambiguities + covariance) in the
+     * solution for ambiguity-resolved positioning. Default false. */
+    exposeState?: boolean;
     /** High-rate precise satellite clocks (RINEX CLOCK, typically 30 s). When
      * given, satellite clock offsets come from this by linear interpolation
      * instead of the SP3 5-minute clocks — the dominant PPP accuracy term.
@@ -669,6 +672,31 @@ interface PppSolution {
     /** Per-arc converged float ambiguities — one per continuous satellite
      * tracking arc — the raw material for ambiguity resolution (PPP-AR). */
     arcs: PppArc[];
+    /** Final EKF state (position + active ambiguities + full covariance) for
+     * ambiguity-resolved (fixed) positioning. Present only when
+     * `PppOptions.exposeState` is set. */
+    finalState?: PppFixState;
+}
+/** Final float state exposed for PPP-AR position fixing (`fixPppPosition`). */
+interface PppFixState {
+    /** Float position (m); rows 0–2 of the covariance. */
+    position: [number, number, number];
+    /** Full EKF covariance (n×n). State order: X,Y,Z,ZWD, clocks…, ambiguities. */
+    covariance: number[][];
+    /** Active ambiguities at the final epoch. */
+    ambiguities: {
+        prn: string;
+        /** Row/column of this ambiguity in `covariance`. */
+        index: number;
+        /** Float ionosphere-free ambiguity (m). */
+        aIF: number;
+        /** Arc-averaged Melbourne–Wübbena wide-lane (cycles). */
+        mwCyc: number;
+        f1: number;
+        f2: number;
+        /** Mean satellite elevation over the arc (deg). */
+        elevDeg: number;
+    }[];
 }
 /** A converged carrier-phase arc: the float ionosphere-free ambiguity plus
  * the wide-lane, for integer resolution / FCB estimation. */
@@ -759,6 +787,7 @@ declare function solidEarthTide(rcv: [number, number, number], sun: [number, num
  * 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). */
@@ -812,6 +841,38 @@ interface ArResult {
  * confident fix (keep the float solution).
  */
 declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
+interface FixedPositionResult {
+    /** Whether the narrow-lane fix passed the ratio test. */
+    fixed: boolean;
+    /** Ambiguity-fixed position (m); equals `floatPosition` when not fixed. */
+    position: [number, number, number];
+    /** The input float position (m). */
+    floatPosition: [number, number, number];
+    /** Displacement fixed − float (m), ENU-agnostic ECEF. */
+    shift: [number, number, number];
+    /** Satellites whose ambiguities were fixed (excl. the SD reference). */
+    nFixed: number;
+    ratio: number;
+    refPrn: string | null;
+}
+/**
+ * Ambiguity-fixed (PPP-AR) position from a float `solvePpp` final state and
+ * the satellite fractional-cycle biases (from `estimateNetworkFcbs`).
+ *
+ * Resolves the integers (`resolvePppAmbiguities`), then **conditions the
+ * float position on the fixed between-satellite ambiguities** — the standard
+ * constrained solution
+ *   x_fixed = x_float − Q_xz · Q_zz⁻¹ · (z_float − ẑ),
+ * where z = D·a are the single-differenced ambiguities (D removes the
+ * reference satellite, cancelling the receiver term), Q_zz = D·Q_aa·Dᵀ and
+ * Q_xz = Q_xa·Dᵀ come from the EKF covariance. Only satellite-to-satellite
+ * integers constrain the position; the reference (and the receiver clock it
+ * absorbs) stays free. Returns the float position unchanged if the fix fails.
+ */
+declare function fixPppPosition(state: PppFixState, fcb: {
+    satWlFcb: Map<string, number>;
+    satNlFcb: Map<string, number>;
+}, opts?: ArOptions): FixedPositionResult;
 
 /**
  * Wide-lane fractional-cycle bias (FCB) estimation for PPP-AR — the
@@ -932,6 +993,40 @@ interface NlFcbResult extends WlFcbResult {
  * — the fix rate is the honest measure of how close the network is to cm.
  */
 declare function estimateNarrowlaneFcb(arcs: NlArc[], wl: WlFcbResult, opts?: WlFcbOptions): NlFcbResult;
+interface NetworkFcbSummary {
+    wlFixRate: number;
+    wlResidRms: number;
+    nlUsedArcs: number;
+    nlFixRate: number;
+    nlResidRms: number;
+    wlRejected: number;
+}
+interface NetworkFcbResult {
+    /** Per-satellite wide-lane FCB (cycles), all constellations merged. */
+    satWlFcb: Map<string, number>;
+    /** Per-satellite narrow-lane FCB (cycles), all constellations merged. */
+    satNlFcb: Map<string, number>;
+    /** Per-constellation fix-rate / residual summary, keyed by system letter. */
+    perSystem: Record<string, NetworkFcbSummary>;
+}
+/**
+ * Full network FCB calibration for PPP-AR from a set of `solvePpp` arcs (each
+ * tagged with its station), **per constellation** — the receiver wide- and
+ * narrow-lane biases are system-specific, so lumping GPS/Galileo/BeiDou under
+ * one datum corrupts the fit. Runs the wide-lane then narrow-lane
+ * decomposition for each system and merges the per-satellite biases.
+ *
+ * The satellite FCBs (`satWlFcb`/`satNlFcb`) are the reusable product: a rover
+ * applies them and solves only its own receiver bias. Multi-GNSS input
+ * multiplies the fixable arcs (Galileo roughly doubles GPS-only) without
+ * changing per-arc behaviour — each satellite's arc length is independent of
+ * how many constellations are present.
+ */
+declare function estimateNetworkFcbs(arcs: NlArc[], opts?: {
+    minArcEpochs?: number;
+    minWlObs?: number;
+    fixWindow?: number;
+}): NetworkFcbResult;
 
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
@@ -1022,4 +1117,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 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 NlArc, type NlFcbResult, type PppAntennaModel, type PppArc, 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, estimateNarrowlaneFcb, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };
+export { type AntennaOffset, type ArFixedSat, type ArOptions, type ArResult, type ArSat, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, type FixedPositionResult, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type NetworkFcbResult, type NetworkFcbSummary, type NlArc, type NlFcbResult, type PppAntennaModel, type PppArc, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppFixState, 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, estimateNarrowlaneFcb, estimateNetworkFcbs, estimateWidelaneFcb, extractWidelaneArcs, fixPppPosition, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };

package/dist/positioning.d.ts

@@ -631,6 +631,9 @@ interface PppOptions {
     ztdProcessNoise?: number;
     /** Model + estimate the troposphere. Default true. */
     troposphere?: boolean;
+    /** Expose the final EKF state (position + ambiguities + covariance) in the
+     * solution for ambiguity-resolved positioning. Default false. */
+    exposeState?: boolean;
     /** High-rate precise satellite clocks (RINEX CLOCK, typically 30 s). When
      * given, satellite clock offsets come from this by linear interpolation
      * instead of the SP3 5-minute clocks — the dominant PPP accuracy term.
@@ -669,6 +672,31 @@ interface PppSolution {
     /** Per-arc converged float ambiguities — one per continuous satellite
      * tracking arc — the raw material for ambiguity resolution (PPP-AR). */
     arcs: PppArc[];
+    /** Final EKF state (position + active ambiguities + full covariance) for
+     * ambiguity-resolved (fixed) positioning. Present only when
+     * `PppOptions.exposeState` is set. */
+    finalState?: PppFixState;
+}
+/** Final float state exposed for PPP-AR position fixing (`fixPppPosition`). */
+interface PppFixState {
+    /** Float position (m); rows 0–2 of the covariance. */
+    position: [number, number, number];
+    /** Full EKF covariance (n×n). State order: X,Y,Z,ZWD, clocks…, ambiguities. */
+    covariance: number[][];
+    /** Active ambiguities at the final epoch. */
+    ambiguities: {
+        prn: string;
+        /** Row/column of this ambiguity in `covariance`. */
+        index: number;
+        /** Float ionosphere-free ambiguity (m). */
+        aIF: number;
+        /** Arc-averaged Melbourne–Wübbena wide-lane (cycles). */
+        mwCyc: number;
+        f1: number;
+        f2: number;
+        /** Mean satellite elevation over the arc (deg). */
+        elevDeg: number;
+    }[];
 }
 /** A converged carrier-phase arc: the float ionosphere-free ambiguity plus
  * the wide-lane, for integer resolution / FCB estimation. */
@@ -759,6 +787,7 @@ declare function solidEarthTide(rcv: [number, number, number], sun: [number, num
  * 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). */
@@ -812,6 +841,38 @@ interface ArResult {
  * confident fix (keep the float solution).
  */
 declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
+interface FixedPositionResult {
+    /** Whether the narrow-lane fix passed the ratio test. */
+    fixed: boolean;
+    /** Ambiguity-fixed position (m); equals `floatPosition` when not fixed. */
+    position: [number, number, number];
+    /** The input float position (m). */
+    floatPosition: [number, number, number];
+    /** Displacement fixed − float (m), ENU-agnostic ECEF. */
+    shift: [number, number, number];
+    /** Satellites whose ambiguities were fixed (excl. the SD reference). */
+    nFixed: number;
+    ratio: number;
+    refPrn: string | null;
+}
+/**
+ * Ambiguity-fixed (PPP-AR) position from a float `solvePpp` final state and
+ * the satellite fractional-cycle biases (from `estimateNetworkFcbs`).
+ *
+ * Resolves the integers (`resolvePppAmbiguities`), then **conditions the
+ * float position on the fixed between-satellite ambiguities** — the standard
+ * constrained solution
+ *   x_fixed = x_float − Q_xz · Q_zz⁻¹ · (z_float − ẑ),
+ * where z = D·a are the single-differenced ambiguities (D removes the
+ * reference satellite, cancelling the receiver term), Q_zz = D·Q_aa·Dᵀ and
+ * Q_xz = Q_xa·Dᵀ come from the EKF covariance. Only satellite-to-satellite
+ * integers constrain the position; the reference (and the receiver clock it
+ * absorbs) stays free. Returns the float position unchanged if the fix fails.
+ */
+declare function fixPppPosition(state: PppFixState, fcb: {
+    satWlFcb: Map<string, number>;
+    satNlFcb: Map<string, number>;
+}, opts?: ArOptions): FixedPositionResult;
 
 /**
  * Wide-lane fractional-cycle bias (FCB) estimation for PPP-AR — the
@@ -932,6 +993,40 @@ interface NlFcbResult extends WlFcbResult {
  * — the fix rate is the honest measure of how close the network is to cm.
  */
 declare function estimateNarrowlaneFcb(arcs: NlArc[], wl: WlFcbResult, opts?: WlFcbOptions): NlFcbResult;
+interface NetworkFcbSummary {
+    wlFixRate: number;
+    wlResidRms: number;
+    nlUsedArcs: number;
+    nlFixRate: number;
+    nlResidRms: number;
+    wlRejected: number;
+}
+interface NetworkFcbResult {
+    /** Per-satellite wide-lane FCB (cycles), all constellations merged. */
+    satWlFcb: Map<string, number>;
+    /** Per-satellite narrow-lane FCB (cycles), all constellations merged. */
+    satNlFcb: Map<string, number>;
+    /** Per-constellation fix-rate / residual summary, keyed by system letter. */
+    perSystem: Record<string, NetworkFcbSummary>;
+}
+/**
+ * Full network FCB calibration for PPP-AR from a set of `solvePpp` arcs (each
+ * tagged with its station), **per constellation** — the receiver wide- and
+ * narrow-lane biases are system-specific, so lumping GPS/Galileo/BeiDou under
+ * one datum corrupts the fit. Runs the wide-lane then narrow-lane
+ * decomposition for each system and merges the per-satellite biases.
+ *
+ * The satellite FCBs (`satWlFcb`/`satNlFcb`) are the reusable product: a rover
+ * applies them and solves only its own receiver bias. Multi-GNSS input
+ * multiplies the fixable arcs (Galileo roughly doubles GPS-only) without
+ * changing per-arc behaviour — each satellite's arc length is independent of
+ * how many constellations are present.
+ */
+declare function estimateNetworkFcbs(arcs: NlArc[], opts?: {
+    minArcEpochs?: number;
+    minWlObs?: number;
+    fixWindow?: number;
+}): NetworkFcbResult;
 
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
@@ -1022,4 +1117,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 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 NlArc, type NlFcbResult, type PppAntennaModel, type PppArc, 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, estimateNarrowlaneFcb, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };
+export { type AntennaOffset, type ArFixedSat, type ArOptions, type ArResult, type ArSat, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, type FixedPositionResult, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type NetworkFcbResult, type NetworkFcbSummary, type NlArc, type NlFcbResult, type PppAntennaModel, type PppArc, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppFixState, 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, estimateNarrowlaneFcb, estimateNetworkFcbs, estimateWidelaneFcb, extractWidelaneArcs, fixPppPosition, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };

package/dist/positioning.js

@@ -4,8 +4,10 @@ import {
   buildPppAntenna,
   createPppCorrections,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -25,7 +27,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-H73PZB5C.js";
+} from "./chunk-3FG4XVCB.js";
 import "./chunk-MHGNKSSH.js";
 import "./chunk-37QNKGTC.js";
 import "./chunk-6FAL6P4G.js";
@@ -39,8 +41,10 @@ export {
   buildPppAntenna,
   createPppCorrections,
   estimateNarrowlaneFcb,
+  estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,

package/package.json

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