gnss-js 1.35.0 → 1.36.0

package/dist/{chunk-BLGBMRX7.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 = {}) {
@@ -2504,6 +2638,7 @@ export {
   wlWavelength,
   nlWavelength,
   resolvePppAmbiguities,
+  fixPppPosition,
   extractWidelaneArcs,
   estimateWidelaneFcb,
   estimateNarrowlaneFcb,

package/dist/index.cjs

@@ -156,6 +156,7 @@ __export(src_exports, {
   extractWidelaneArcs: () => extractWidelaneArcs,
   fetchSourcetable: () => fetchSourcetable,
   findSatBias: () => findSatBias,
+  fixPppPosition: () => fixPppPosition,
   fmtD: () => fmtD,
   fmtF: () => fmtF,
   formatUTCTime: () => formatUTCTime,
@@ -13357,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]);
@@ -13373,7 +13396,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -13466,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 = {}) {
@@ -16277,6 +16412,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   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, NetworkFcbResult, NetworkFcbSummary, 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, estimateNetworkFcbs, 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, NetworkFcbResult, NetworkFcbSummary, 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, estimateNetworkFcbs, 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

@@ -150,6 +150,7 @@ import {
   estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -169,7 +170,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-BLGBMRX7.js";
+} from "./chunk-3FG4XVCB.js";
 import {
   almanacEpochMs,
   almanacSatPosition,
@@ -483,6 +484,7 @@ export {
   extractWidelaneArcs,
   fetchSourcetable,
   findSatBias,
+  fixPppPosition,
   fmtD,
   fmtF,
   formatUTCTime,

package/dist/positioning.cjs

@@ -28,6 +28,7 @@ __export(positioning_exports, {
   estimateNetworkFcbs: () => estimateNetworkFcbs,
   estimateWidelaneFcb: () => estimateWidelaneFcb,
   extractWidelaneArcs: () => extractWidelaneArcs,
+  fixPppPosition: () => fixPppPosition,
   gimSlantIonoDelayL1: () => gimSlantIonoDelayL1,
   gimVerticalTec: () => gimVerticalTec,
   gmst: () => gmst,
@@ -2485,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]);
@@ -2501,7 +2524,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -2594,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 = {}) {
@@ -3018,6 +3153,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   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
@@ -1056,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 NetworkFcbResult, type NetworkFcbSummary, 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, estimateNetworkFcbs, 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
@@ -1056,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 NetworkFcbResult, type NetworkFcbSummary, 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, estimateNetworkFcbs, 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

@@ -7,6 +7,7 @@ import {
   estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -26,7 +27,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-BLGBMRX7.js";
+} from "./chunk-3FG4XVCB.js";
 import "./chunk-MHGNKSSH.js";
 import "./chunk-37QNKGTC.js";
 import "./chunk-6FAL6P4G.js";
@@ -43,6 +44,7 @@ export {
   estimateNetworkFcbs,
   estimateWidelaneFcb,
   extractWidelaneArcs,
+  fixPppPosition,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnss-js",
-  "version": "1.35.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,