gnss-js 2.10.1 → 2.12.0

package/dist/{chunk-K3GLUWZI.js → chunk-RWFJEVLJ.js}

@@ -1,6 +1,6 @@
 import {
   sbasMessageType
-} from "./chunk-WQX354KD.js";
+} from "./chunk-H3AKFD25.js";
 import {
   computeDop,
   computeSatPosition,
@@ -265,6 +265,12 @@ function solveZt(n, m, Z, E) {
     for (let cIdx = 0; cIdx < m; cIdx++) X[r + cIdx * n] = M[r * w + n + cIdx];
   return X;
 }
+function normCdf(x) {
+  const z = Math.abs(x) / Math.SQRT2;
+  const t = 1 / (1 + 0.3275911 * z);
+  const erf = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-z * z);
+  return x >= 0 ? 0.5 * (1 + erf) : 0.5 * (1 - erf);
+}
 function lambdaSearch(a, Q, n, m = 2) {
   if (n <= 0 || m <= 0 || a.length < n || Q.length < n * n) return null;
   const L = new Float64Array(n * n);
@@ -291,7 +297,10 @@ function lambdaSearch(a, Q, n, m = 2) {
     candidates.push(v);
   }
   const ratio = m >= 2 && s[0] > 0 ? s[1] / s[0] : Infinity;
-  return { candidates, residuals: s, ratio };
+  let successRate = 1;
+  for (let i = 0; i < n; i++)
+    successRate *= 2 * normCdf(1 / (2 * Math.sqrt(D[i]))) - 1;
+  return { candidates, residuals: s, ratio, successRate };
 }
 function lambdaReduction(Q, n) {
   if (n <= 0 || Q.length < n * n) return null;
@@ -306,7 +315,7 @@ function lambdaReduction(Q, n) {
 
 // src/positioning/ppp-antenna.ts
 function parseAntexTime(s) {
-  const p = s.trim().split(/\s+/).map(Number);
+  const p = s.trim().split(/[\s:-]+/).map(Number);
   if (p.length < 3 || p.some((v) => Number.isNaN(v))) return null;
   return Date.UTC(
     p[0],
@@ -356,11 +365,21 @@ function buildPppAntenna(antex) {
     satOffset(prn, dateMs, band1, band2, f1, f2) {
       const list = sats.get(prn);
       if (!list) return null;
-      const entry = list.find((e) => {
-        const from = parseAntexTime(e.validFrom);
-        const until = parseAntexTime(e.validUntil);
-        return (from == null || dateMs >= from) && (until == null || dateMs <= until);
-      });
+      let entry;
+      let bestDist = Infinity;
+      for (const e of list) {
+        const from = parseAntexTime(e.validFrom) ?? -Infinity;
+        const until = parseAntexTime(e.validUntil) ?? Infinity;
+        if (dateMs >= from && dateMs <= until) {
+          entry = e;
+          break;
+        }
+        const dist = dateMs < from ? from - dateMs : dateMs - until;
+        if (dist < bestDist) {
+          bestDist = dist;
+          entry = e;
+        }
+      }
       if (!entry) return null;
       const a = freqOf(entry, band1);
       const b = freqOf(entry, band2);
@@ -368,10 +387,14 @@ function buildPppAntenna(antex) {
       return withZen(entry, combineIf(a, b, f1, f2));
     },
     rcvOffset(antType, band1, band2, f1, f2) {
-      const entry = rcvs.get(antType);
+      const entry = rcvs.get(antType) ?? rcvs.get(antType.substring(0, 16).padEnd(16, " ") + "NONE");
       if (!entry) return null;
-      const a = freqOf(entry, band1);
-      const b = freqOf(entry, band2);
+      let a = freqOf(entry, band1);
+      let b = freqOf(entry, band2);
+      if (!a || !b) {
+        a = freqOf(entry, "G01");
+        b = freqOf(entry, "G02");
+      }
       if (!a || !b) return null;
       return withZen(entry, combineIf(a, b, f1, f2));
     }
@@ -447,13 +470,13 @@ function phaseWindup(prn, losRcvToSat, satFrame, latRad, lonRad, state) {
     kx[2] - k[2] * kdotx - kcrossY[2]
   ];
   const north = enuToEcef([0, 1, 0], latRad, lonRad);
-  const east = enuToEcef([1, 0, 0], latRad, lonRad);
+  const west = enuToEcef([-1, 0, 0], latRad, lonRad);
   const kdotn = dot(k, north);
-  const kcrossE = cross(k, east);
+  const kcrossW = cross(k, west);
   const dR = [
-    north[0] - k[0] * kdotn + kcrossE[0],
-    north[1] - k[1] * kdotn + kcrossE[1],
-    north[2] - k[2] * kdotn + kcrossE[2]
+    north[0] - k[0] * kdotn + kcrossW[0],
+    north[1] - k[1] * kdotn + kcrossW[1],
+    north[2] - k[2] * kdotn + kcrossW[2]
   ];
   const nS = Math.hypot(dS[0], dS[1], dS[2]) || 1;
   const nR = Math.hypot(dR[0], dR[1], dR[2]) || 1;
@@ -580,9 +603,11 @@ function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, tropo
   let baseLatRad = 0;
   let baseLonRad = 0;
   if (antenna?.base) {
-    const [latDeg, lonDeg] = ecefToGeodetic(basePos[0], basePos[1], basePos[2]);
-    baseLatRad = latDeg * Math.PI / 180;
-    baseLonRad = lonDeg * Math.PI / 180;
+    [baseLatRad, baseLonRad] = ecefToGeodetic(
+      basePos[0],
+      basePos[1],
+      basePos[2]
+    );
   }
   for (const [prn, mR] of rover) {
     const sys = prn[0];
@@ -678,12 +703,12 @@ function roverTerms(g, x, y, z, troposphere) {
     dTropo = tropoDelay(Math.max(elR, 0.05)) - g.tropoB;
   }
   if (g.offR) {
-    const [latDeg, lonDeg] = ecefToGeodetic(x, y, z);
+    const [latRad, lonRad] = ecefToGeodetic(x, y, z);
     rho += rcvAntennaRangeM(
       g.offR,
       [-u[0], -u[1], -u[2]],
-      latDeg * Math.PI / 180,
-      lonDeg * Math.PI / 180,
+      latRad,
+      lonRad,
       elR,
       g.roverDelta
     );
@@ -2498,6 +2523,234 @@ function hasToOrbitClock(orbit, clock, refTimeMs, validitySeconds) {
   };
 }
 
+// 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 minPartial = opts.minPartial ?? 4;
+  const minSuccess = opts.minSuccessRate ?? 0;
+  const n = sats.length;
+  const none = (rejectedWl2, ratio = 0) => ({
+    fixed: false,
+    ratio,
+    refPrn: null,
+    refPrns: [],
+    sats: [],
+    rejectedWl: rejectedWl2
+  });
+  const elev = (i) => sats[i].elevDeg ?? -1;
+  const wlOf = (i) => sats[i].mwCyc - (sats[i].wlBiasCyc ?? 0);
+  const refOfSys = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const sys = sats[i].prn[0];
+    const r = refOfSys.get(sys);
+    if (r === void 0 || elev(i) > elev(r)) refOfSys.set(sys, i);
+  }
+  const nWlOf = /* @__PURE__ */ new Map();
+  const refIdx = /* @__PURE__ */ new Map();
+  const rejectedWl = [];
+  for (const r of refOfSys.values()) {
+    nWlOf.set(r, Math.round(wlOf(r)));
+    refIdx.set(r, r);
+  }
+  for (let i = 0; i < n; i++) {
+    if (refIdx.has(i)) continue;
+    const r = refOfSys.get(sats[i].prn[0]);
+    const sdWl = wlOf(i) - wlOf(r);
+    const k = Math.round(sdWl);
+    if (Math.abs(sdWl - k) <= wlThreshold) {
+      nWlOf.set(i, nWlOf.get(r) + k);
+      refIdx.set(i, r);
+    } else rejectedWl.push(sats[i].prn);
+  }
+  const lamNl = (i) => nlWavelength(sats[i].f1, sats[i].f2);
+  const n1Float = (i) => {
+    const s = sats[i];
+    return s.aIF / lamNl(i) - s.f2 / (s.f1 - s.f2) * nWlOf.get(i) - (s.nlBiasCyc ?? 0);
+  };
+  const qN1 = (a, b) => Qaif[a * n + b] / (lamNl(a) * lamNl(b));
+  let cand = [...refIdx.keys()].filter((i) => refIdx.get(i) !== i).sort((a, b) => elev(b) - elev(a));
+  if (cand.length < 1) return none(rejectedWl);
+  let best = null;
+  let firstRatio = 0;
+  for (; ; ) {
+    const m = cand.length;
+    const sd = new Float64Array(m);
+    const Qsd = new Float64Array(m * m);
+    for (let a = 0; a < m; a++) {
+      const ia = cand[a];
+      const ra = refIdx.get(ia);
+      sd[a] = n1Float(ia) - n1Float(ra);
+      for (let b = 0; b < m; b++) {
+        const ib = cand[b];
+        const rb = refIdx.get(ib);
+        Qsd[a * m + b] = qN1(ia, ib) - qN1(ia, rb) - qN1(ra, ib) + qN1(ra, rb);
+      }
+    }
+    const res = lambdaSearch(sd, Qsd, m, 2);
+    const ratio = res ? Math.min(res.ratio, 999.9) : 0;
+    if (best === null && firstRatio === 0) firstRatio = ratio;
+    if (res && ratio >= ratioThreshold && res.successRate >= minSuccess) {
+      best = { set: cand, ratio, fix: Float64Array.from(res.candidates[0]) };
+      break;
+    }
+    if (m <= minPartial) break;
+    cand = cand.slice(0, -1);
+  }
+  if (!best) return { ...none(rejectedWl, firstRatio), refPrn: null };
+  const refN1 = /* @__PURE__ */ new Map();
+  for (const r of refOfSys.values()) refN1.set(r, Math.round(n1Float(r)));
+  const out = [];
+  const emit = (i, n1) => {
+    const s = sats[i];
+    const l = lamNl(i);
+    const nWl = nWlOf.get(i);
+    out.push({
+      prn: s.prn,
+      nWl,
+      n1,
+      aIF: l * n1 + l * (s.f2 / (s.f1 - s.f2)) * nWl,
+      ref: sats[refIdx.get(i)].prn
+    });
+  };
+  const usedRefs = new Set(best.set.map((i) => refIdx.get(i)));
+  for (const r of usedRefs) emit(r, refN1.get(r));
+  best.set.forEach(
+    (i, a) => emit(i, refN1.get(refIdx.get(i)) + Math.round(best.fix[a]))
+  );
+  const refPrns = [...usedRefs].map((r) => sats[r].prn);
+  return {
+    fixed: true,
+    ratio: best.ratio,
+    refPrn: refPrns[0] ?? null,
+    refPrns,
+    sats: out,
+    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,
+    minPartial: opts.minPartial ?? Math.max(4, opts.minFixed ?? 0)
+  });
+  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 fixedOf = new Map(res.sats.map((s) => [s.prn, s.aIF]));
+  const pairs = res.sats.filter(
+    (s) => s.ref !== s.prn && idxOfPrn.has(s.prn) && idxOfPrn.has(s.ref)
+  ).map((s) => ({ prn: s.prn, ref: s.ref }));
+  const m = pairs.length;
+  if (m < Math.max(1, opts.minFixed ?? 1))
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  const P = state.covariance;
+  const ix = (prn) => idxOfPrn.get(prn);
+  const qAA = (i, j) => P[ix(i)][ix(j)];
+  const qXA = (r, i) => P[r][ix(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 { prn: ia, ref: ra } = pairs[a];
+    z[a] = floatOfPrn.get(ia) - floatOfPrn.get(ra) - (fixedOf.get(ia) - fixedOf.get(ra));
+    for (let b = 0; b < m; b++) {
+      const { prn: ib, ref: rb } = pairs[b];
+      Qzz[a][b] = qAA(ia, ib) - qAA(ia, rb) - qAA(ra, ib) + qAA(ra, rb);
+    }
+  }
+  const Qxz = [0, 1, 2].map(
+    (r) => pairs.map(({ prn, ref }) => qXA(r, prn) - qXA(r, ref))
+  );
+  const y = solveSpd(Qzz, z);
+  if (!y) return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  let chi2 = 0;
+  for (let a = 0; a < m; a++) chi2 += z[a] * y[a];
+  if (chi2 / m > (opts.maxChi2 ?? Infinity))
+    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-tropo.ts
 var HYD_AVG_A = [
   0.0012769934,
@@ -2705,13 +2958,11 @@ function createPppCorrections(cfg) {
       let rangeM = 0;
       let phaseWindupM = 0;
       const e = geom.los;
-      const [latDeg, lonDeg] = ecefToGeodetic(
+      const [latRad, lonRad] = ecefToGeodetic(
         geom.rcvEcef[0],
         geom.rcvEcef[1],
         geom.rcvEcef[2]
       );
-      const latRad = latDeg * Math.PI / 180;
-      const lonRad = lonDeg * Math.PI / 180;
       const frame = ctx ? satBodyFrame(geom.satEcef, ctx.sun) : null;
       if (useSat && frame && geom.band1 && geom.band2) {
         const off = cfg.antenna.satOffset(
@@ -2769,6 +3020,10 @@ function createPppCorrections(cfg) {
 }
 
 // src/positioning/ppp.ts
+var NO_FCB = {
+  satWlFcb: /* @__PURE__ */ new Map(),
+  satNlFcb: /* @__PURE__ */ new Map()
+};
 function matVec(P, h) {
   const n = P.length;
   const out = new Array(n).fill(0);
@@ -2780,6 +3035,34 @@ function matVec(P, h) {
   }
   return out;
 }
+function tdLsq(qs) {
+  const M = [0, 1, 2, 3].map(() => [0, 0, 0, 0, 0]);
+  for (const q of qs) {
+    const a = [-q.v.e[0], -q.v.e[1], -q.v.e[2], 1];
+    for (let i = 0; i < 4; i++) {
+      M[i][4] += a[i] * q.d;
+      for (let j = 0; j < 4; j++) M[i][j] += a[i] * a[j];
+    }
+  }
+  for (let c = 0; c < 4; c++) {
+    let p = c;
+    for (let r = c + 1; r < 4; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[p][c])) p = r;
+    if (Math.abs(M[p][c]) < 1e-9) return null;
+    [M[c], M[p]] = [M[p], M[c]];
+    for (let r = 0; r < 4; r++) {
+      if (r === c) continue;
+      const f = M[r][c] / M[c][c];
+      for (let k = c; k < 5; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  return [0, 1, 2, 3].map((i) => M[i][4] / M[i][i]);
+}
+function tdResidual(q, s) {
+  return q.d - (-q.v.e[0] * s[0] - q.v.e[1] * s[1] - q.v.e[2] * s[2] + s[3]);
+}
+var TD_SLIP_M = 0.08;
+var CODE_GATE_M = 15;
 function ekfUpdateScalar(x, P, h, innovation, r, rejectK = 0) {
   const n = x.length;
   const Ph = matVec(P, h);
@@ -2812,10 +3095,17 @@ function ifCoeffs(f1, f2) {
   return { g, lambdaIf };
 }
 var Sp3EphemerisSource = class {
-  constructor(sp3, clk) {
+  constructor(sp3, clk, osb) {
     this.sp3 = sp3;
     this.clk = clk;
+    this.osb = osb;
+    if (osb) {
+      this.codeBias = (prn, code, t) => osb.get(prn, "C" + code, t);
+      this.phaseBias = (prn, code, t) => osb.get(prn, "L" + code, t);
+    }
   }
+  codeBias;
+  phaseBias;
   satState(prn, tEmitMs) {
     const p = sp3Position(this.sp3, prn, tEmitMs);
     if (!p || p.clk == null) return null;
@@ -2833,6 +3123,21 @@ var Sp3EphemerisSource = class {
     return { x: p.x, y: p.y, z: p.z, vx, vy, vz, clkS };
   }
 };
+function applySatBiases(source, o, tMs) {
+  if (!source.codeBias && !source.phaseBias) return o;
+  const b1 = source.codeBias?.(o.prn, o.code1 ?? "", tMs) ?? 0;
+  const b2 = source.codeBias?.(o.prn, o.code2 ?? "", tMs) ?? 0;
+  let l1 = o.l1;
+  let l2 = o.l2;
+  if (source.phaseBias) {
+    const p1 = source.phaseBias(o.prn, o.phase1 ?? o.code1 ?? "", tMs);
+    const p2 = source.phaseBias(o.prn, o.phase2 ?? o.code2 ?? "", tMs);
+    if (p1 == null || p2 == null) return null;
+    l1 -= p1 / (C_LIGHT / o.f1);
+    l2 -= p2 / (C_LIGHT / o.f2);
+  }
+  return { ...o, c1: o.c1 - b1, c2: o.c2 - b2, l1, l2 };
+}
 function sagnacRotate(x, y, z, travelS) {
   const theta = OMEGA_E * travelS;
   const c = Math.cos(theta);
@@ -2894,6 +3199,16 @@ var PppEngine = class {
   arcs;
   arcSnap;
   mwState;
+  /** Previous epoch's phase terms per satellite, for the time-differenced
+   *  (clock-free) cycle-slip test. */
+  tdPrev;
+  /** Consecutive gated-out phase updates per satellite. */
+  phaseRejects;
+  /** PPP-AR: the latest accepted fix (null: float). */
+  lastFix;
+  lastArMs;
+  firstFixMs;
+  fixedEpochs;
   series;
   ei = 0;
   t0 = 0;
@@ -2929,6 +3244,12 @@ var PppEngine = class {
     this.arcs = [];
     this.arcSnap = /* @__PURE__ */ new Map();
     this.mwState = /* @__PURE__ */ new Map();
+    this.tdPrev = /* @__PURE__ */ new Map();
+    this.phaseRejects = /* @__PURE__ */ new Map();
+    this.lastFix = null;
+    this.lastArMs = -Infinity;
+    this.firstFixMs = null;
+    this.fixedEpochs = 0;
     this.series = [];
     this.ei = 0;
     this.t0 = 0;
@@ -3022,7 +3343,9 @@ var PppEngine = class {
       lastSeen,
       arcSnap,
       mwState,
-      series
+      series,
+      tdPrev,
+      phaseRejects
     } = this;
     const flushArc = this.flushArc.bind(this);
     const detectSlip = this.detectSlip.bind(this);
@@ -3044,13 +3367,15 @@ var PppEngine = class {
     for (const ci of clkIdx.values()) P[ci][ci] = CLK_VAR;
     P[IDX_ZWD][IDX_ZWD] += ztdQ * (ei > 0 ? 1 : 0);
     const rcv = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
-    const [latDeg, , heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
-    const latRad = latDeg * Math.PI / 180;
+    const [latRad, , heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
     const epochCtx = corrections?.epochContext?.(epoch.timeMs, rcv) ?? null;
     const vis = [];
     let epochZhd = 0;
-    for (const o of epoch.obs) {
-      if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
+    for (const raw of epoch.obs) {
+      if (raw.c1 === 0 || raw.c2 === 0 || raw.l1 === 0 || raw.l2 === 0)
+        continue;
+      const o = applySatBiases(source, raw, epoch.timeMs);
+      if (!o) continue;
       const slip = detectSlip(o, ei);
       const sat = satStateAtEmission(source, o.prn, epoch.timeMs, rcv);
       if (!sat) continue;
@@ -3072,9 +3397,7 @@ var PppEngine = class {
       const lam1 = C_LIGHT / o.f1;
       const lam2 = C_LIGHT / o.f2;
       if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
-      const b1 = source.codeBias?.(o.prn, o.code1 ?? "", epoch.timeMs) ?? 0;
-      const b2 = source.codeBias?.(o.prn, o.code2 ?? "", epoch.timeMs) ?? 0;
-      const pIf = g * (o.c1 - b1) - (g - 1) * (o.c2 - b2);
+      const pIf = g * o.c1 - (g - 1) * o.c2;
       const lIf = g * (o.l1 * lam1) - (g - 1) * (o.l2 * lam2);
       if (!Number.isFinite(pIf) || !Number.isFinite(lIf)) continue;
       const trop = opts.troposphere ?? true ? niellMapping(elRad, latRad, heightM, epoch.timeMs) : { zhd: 0, mh: 0, mw: 0 };
@@ -3107,9 +3430,63 @@ var PppEngine = class {
         windupM: corr.phaseWindupM,
         slip,
         f1: o.f1,
-        f2: o.f2
+        f2: o.f2,
+        sat: [sat.state.x, sat.state.y, sat.state.z]
       });
     }
+    {
+      const dq = [];
+      for (const v of vis) {
+        const prev = tdPrev.get(v.prn);
+        const model = -v.satClkM + v.tropoFixed + v.windupM;
+        if (prev && prev.ei === ei - 1 && !v.slip) {
+          const r0 = Math.hypot(
+            prev.sat[0] - rcv[0],
+            prev.sat[1] - rcv[1],
+            prev.sat[2] - rcv[2]
+          );
+          dq.push({
+            v,
+            d: v.lIf - prev.lIf - (v.range - r0) - (model - prev.model)
+          });
+        }
+        tdPrev.set(v.prn, { ei, lIf: v.lIf, sat: v.sat, model });
+      }
+      if (!kinematic) {
+        if (dq.length >= 4) {
+          const sorted = dq.map((q) => q.d).sort((a, b) => a - b);
+          const med = sorted[Math.floor(sorted.length / 2)];
+          for (const q of dq)
+            if (Math.abs(q.d - med) > TD_SLIP_M) q.v.slip = true;
+        }
+      } else if (dq.length >= 6) {
+        let use = dq;
+        for (let iter = 0; iter < 6; iter++) {
+          const sol = use.length >= 6 ? tdLsq(use) : null;
+          if (!sol) {
+            for (const q of dq) q.v.slip = true;
+            break;
+          }
+          let worst = -1;
+          let worstR = 0;
+          use.forEach((q, k) => {
+            const r = Math.abs(tdResidual(q, sol));
+            if (r > worstR) {
+              worstR = r;
+              worst = k;
+            }
+          });
+          if (worstR <= TD_SLIP_M || iter === 5) {
+            for (const q of dq)
+              if (Math.abs(tdResidual(q, sol)) > TD_SLIP_M) q.v.slip = true;
+            break;
+          }
+          use = use.filter((_, k) => k !== worst);
+        }
+      } else {
+        for (const q of dq) q.v.slip = true;
+      }
+    }
     const zwd0 = x[IDX_ZWD];
     const bySys = /* @__PURE__ */ new Map();
     for (const v of vis) {
@@ -3119,6 +3496,20 @@ var PppEngine = class {
       if (arr) arr.push(r);
       else bySys.set(sys, [r]);
     }
+    const posSigma = Math.sqrt(
+      P[IDX_X][IDX_X] + P[IDX_Y][IDX_Y] + P[IDX_Z][IDX_Z]
+    );
+    const codeGate = CODE_GATE_M + 3 * posSigma;
+    const screened = /* @__PURE__ */ new Set();
+    for (const [sys, res] of bySys) {
+      if (res.length < 4) continue;
+      const med = [...res].sort((a, b) => a - b)[Math.floor(res.length / 2)];
+      for (const v of vis) {
+        if (v.prn[0] !== sys) continue;
+        const r = v.pIf - (v.range - v.satClkM + v.tropoFixed + zwd0 * v.mw);
+        if (Math.abs(r - med) > codeGate) screened.add(v.prn);
+      }
+    }
     for (const [sys, res] of bySys) {
       const ci = clockOf(sys);
       if (!clockSeeded.has(sys)) {
@@ -3129,9 +3520,11 @@ var PppEngine = class {
       P[ci][ci] = CLK_VAR;
     }
     let nSats = 0;
-    for (const v of vis) {
+    const live = vis.filter((v) => !screened.has(v.prn));
+    const rangeNow = (v) => v.range - (v.e[0] * (x[IDX_X] - rcv[0]) + v.e[1] * (x[IDX_Y] - rcv[1]) + v.e[2] * (x[IDX_Z] - rcv[2]));
+    const prepAmbiguity = (v) => {
       const ci = clockOf(v.prn[0]);
-      const common = v.range + x[ci] - v.satClkM + v.tropoFixed + zwd0 * v.mw;
+      const common = rangeNow(v) + x[ci] - v.satClkM + v.tropoFixed + zwd0 * v.mw;
       if (v.slip) flushArc(v.prn);
       let ai = ambIdx.get(v.prn);
       if (ai === void 0 || v.slip) {
@@ -3148,67 +3541,91 @@ var PppEngine = class {
         }
         ambIdx.set(v.prn, ai);
       }
-      const n = x.length;
+      return ai;
+    };
+    const codeUpdate = (v) => {
+      const ci = clockOf(v.prn[0]);
+      const common = rangeNow(v) + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
+      const sinEl = Math.max(Math.sin(v.elRad), 0.1);
+      const h = new Array(x.length).fill(0);
+      h[IDX_X] = -v.e[0];
+      h[IDX_Y] = -v.e[1];
+      h[IDX_Z] = -v.e[2];
+      h[ci] = 1;
+      h[IDX_ZWD] = v.mw;
+      const innov = v.pIf - common;
+      if (Math.abs(innov) < 1e6)
+        ekfUpdateScalar(x, P, h, innov, (codeSigma / sinEl) ** 2, 4);
+    };
+    const phaseUpdate = (v, ai) => {
+      const ci = clockOf(v.prn[0]);
       const sinEl = Math.max(Math.sin(v.elRad), 0.1);
-      const rCode = (codeSigma / sinEl) ** 2;
       const rPhase = (phaseSigma / sinEl) ** 2;
-      {
-        const h = new Array(n).fill(0);
+      const commonPh = rangeNow(v) + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
+      const innov = v.lIf - (commonPh + v.windupM + x[ai]);
+      const reinit = (phaseRejects.get(v.prn) ?? 0) >= 3;
+      let used = false;
+      if (!reinit) {
+        const h = new Array(x.length).fill(0);
         h[IDX_X] = -v.e[0];
         h[IDX_Y] = -v.e[1];
         h[IDX_Z] = -v.e[2];
         h[ci] = 1;
         h[IDX_ZWD] = v.mw;
-        const innov = v.pIf - common;
-        if (Math.abs(innov) < 1e6) ekfUpdateScalar(x, P, h, innov, rCode, 4);
+        h[ai] = 1;
+        used = ekfUpdateScalar(x, P, h, innov, rPhase, 4);
       }
-      {
-        const commonPh = v.range + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
-        const innov = v.lIf - (commonPh + v.windupM + x[ai]);
-        if (Math.abs(innov) > 0.15) {
-          flushArc(v.prn);
-          x[ai] = v.lIf - (commonPh + v.windupM);
-          for (let j = 0; j < P.length; j++) {
-            P[ai][j] = 0;
-            P[j][ai] = 0;
-          }
-          P[ai][ai] = 100 * 100;
-        } else {
-          const h = new Array(n).fill(0);
-          h[IDX_X] = -v.e[0];
-          h[IDX_Y] = -v.e[1];
-          h[IDX_Z] = -v.e[2];
-          h[ci] = 1;
-          h[IDX_ZWD] = v.mw;
-          h[ai] = 1;
-          ekfUpdateScalar(x, P, h, innov, rPhase, 4);
-        }
-      }
-      {
-        const elevDeg = v.elRad * 180 / Math.PI;
-        const mwMean = mwState.get(v.prn)?.mean ?? 0;
-        const s = arcSnap.get(v.prn);
-        if (s) {
-          s.aIF = x[ai];
-          s.mwCyc = mwMean;
-          s.elevSum += elevDeg;
-          s.nEpochs++;
-          s.endMs = epoch.timeMs;
-        } else {
-          arcSnap.set(v.prn, {
-            aIF: x[ai],
-            mwCyc: mwMean,
-            f1: v.f1,
-            f2: v.f2,
-            elevSum: elevDeg,
-            nEpochs: 1,
-            startMs: epoch.timeMs,
-            endMs: epoch.timeMs
-          });
+      if (reinit) {
+        flushArc(v.prn);
+        x[ai] = v.lIf - (commonPh + v.windupM);
+        for (let j = 0; j < P.length; j++) {
+          P[ai][j] = 0;
+          P[j][ai] = 0;
         }
+        P[ai][ai] = 100 * 100;
+        phaseRejects.delete(v.prn);
+      } else if (used) phaseRejects.delete(v.prn);
+      else phaseRejects.set(v.prn, (phaseRejects.get(v.prn) ?? 0) + 1);
+    };
+    const snapshot = (v, ai) => {
+      const elevDeg = v.elRad * 180 / Math.PI;
+      const mwMean = mwState.get(v.prn)?.mean ?? 0;
+      const s = arcSnap.get(v.prn);
+      if (s) {
+        s.aIF = x[ai];
+        s.mwCyc = mwMean;
+        s.elevSum += elevDeg;
+        s.nEpochs++;
+        s.endMs = epoch.timeMs;
+      } else {
+        arcSnap.set(v.prn, {
+          aIF: x[ai],
+          mwCyc: mwMean,
+          f1: v.f1,
+          f2: v.f2,
+          elevSum: elevDeg,
+          nEpochs: 1,
+          startMs: epoch.timeMs,
+          endMs: epoch.timeMs
+        });
       }
       lastSeen.set(v.prn, ei);
       nSats++;
+    };
+    if (kinematic) {
+      for (const v of live) codeUpdate(v);
+      for (const v of live) {
+        const ai = prepAmbiguity(v);
+        phaseUpdate(v, ai);
+        snapshot(v, ai);
+      }
+    } else {
+      for (const v of live) {
+        const ai = prepAmbiguity(v);
+        codeUpdate(v);
+        phaseUpdate(v, ai);
+        snapshot(v, ai);
+      }
     }
     let sumPhaseResSq = 0;
     let nPhaseRes = 0;
@@ -3219,7 +3636,7 @@ var PppEngine = class {
         if (ai === void 0) continue;
         const sys = v.prn[0];
         const ci = clockOf(sys);
-        const commonPh = v.range + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
+        const commonPh = rangeNow(v) + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
         const innov = v.lIf - (commonPh + v.windupM + x[ai]);
         if (Math.abs(innov) >= 0.15) continue;
         const arr = bySysRes.get(sys);
@@ -3243,6 +3660,8 @@ var PppEngine = class {
         flushArc(prn);
       }
     }
+    this.tryFix(epoch.timeMs, vis);
+    if (this.lastFix) this.fixedEpochs++;
     const pos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
     let enu = null;
     let error3d = null;
@@ -3278,12 +3697,75 @@ var PppEngine = class {
       nSats,
       ztdWet: x[IDX_ZWD],
       ztdHydrostatic: epochZhd,
-      phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
+      phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0,
+      nFixed: this.lastFix?.nFixed ?? 0,
+      fixedPosition: this.lastFix?.position ?? null
     };
     series.push(result);
     this.ei = ei + 1;
     return result;
   }
+  /**
+   * PPP-AR. Every `everyS`, resolve the converged ambiguities of the
+   * satellites in view (between satellites of one constellation) and, when
+   * the fix passes the ratio, success-rate and χ² tests, condition the
+   * float position on it ({@link fixPppPosition}). The float filter itself
+   * is never constrained — a wrong fix can't contaminate later epochs, and
+   * the next attempt starts clean. Between attempts the last fix carries
+   * over (static) or is dropped (kinematic).
+   */
+  tryFix(tMs, vis) {
+    const ar = this.opts.ar;
+    if (!ar || !this.source.phaseBias) return;
+    const cfg = ar === true ? {} : ar;
+    if (tMs - this.lastArMs < (cfg.everyS ?? 120) * 1e3) {
+      if (this.kinematic) this.lastFix = null;
+      return;
+    }
+    this.lastArMs = tMs;
+    this.lastFix = null;
+    const { x, P, ambIdx, arcSnap, mwState } = this;
+    const minArcMs = (cfg.minArcS ?? 600) * 1e3;
+    const ambiguities = [];
+    for (const v of vis) {
+      const index = ambIdx.get(v.prn);
+      const snap = arcSnap.get(v.prn);
+      const mw = mwState.get(v.prn);
+      if (index === void 0 || !snap || !mw) continue;
+      if (tMs - snap.startMs < minArcMs || snap.nEpochs < 20) continue;
+      ambiguities.push({
+        prn: v.prn,
+        index,
+        aIF: x[index],
+        mwCyc: mw.mean,
+        f1: v.f1,
+        f2: v.f2,
+        elevDeg: v.elRad * 180 / Math.PI
+      });
+    }
+    const fx = fixPppPosition(
+      {
+        position: [x[IDX_X], x[IDX_Y], x[IDX_Z]],
+        covariance: P,
+        ambiguities
+      },
+      NO_FCB,
+      {
+        ratioThreshold: cfg.ratio ?? 3,
+        wlThreshold: cfg.wlThreshold ?? 0.15,
+        minSuccessRate: cfg.successRate ?? 0.999,
+        minFixed: cfg.minFixed ?? 5,
+        maxChi2: cfg.maxChi2 ?? 20
+      }
+    );
+    if (!fx.fixed) return;
+    this.lastFix = {
+      position: fx.position,
+      nFixed: fx.nFixed,
+      ratio: fx.ratio
+    };
+    this.firstFixMs ??= tMs;
+  }
   /** Finalise the session: capture the AR state, flush open arcs, assemble. */
   solution() {
     const { opts, x, P, ambIdx, arcSnap, mwState, arcs, series, truth } = this;
@@ -3316,7 +3798,12 @@ var PppEngine = class {
       x[IDX_Y],
       x[IDX_Z]
     ];
-    const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
+    const geo = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
+    const llh = [
+      geo[0] * 180 / Math.PI,
+      geo[1] * 180 / Math.PI,
+      geo[2]
+    ];
     const finalError3d = truth ? Math.hypot(
       finalPos[0] - truth[0],
       finalPos[1] - truth[1],
@@ -3332,218 +3819,25 @@ var PppEngine = class {
       convergenceSec: this.convergenceSec,
       finalError3d,
       arcs,
-      finalState
+      finalState,
+      ...opts.ar && this.source.phaseBias ? {
+        ar: {
+          firstFixSec: this.firstFixMs === null || !series.length ? null : (this.firstFixMs - series[0].timeMs) / 1e3,
+          nFixedEnd: this.lastFix?.nFixed ?? 0,
+          position: this.lastFix?.position ?? null,
+          fixedEpochShare: series.length ? this.fixedEpochs / series.length : 0
+        }
+      } : {}
     };
   }
 };
 function solvePpp(epochs, sp3OrSource, opts) {
-  const source = "satState" in sp3OrSource ? sp3OrSource : new Sp3EphemerisSource(sp3OrSource, opts.clk);
+  const source = "satState" in sp3OrSource ? sp3OrSource : new Sp3EphemerisSource(sp3OrSource, opts.clk, opts.osb);
   const eng = new PppEngine(opts, source);
   for (const epoch of epochs) eng.process(epoch);
   return eng.solution();
 }
 
-// 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
-  };
-}
-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 = {}) {
   const slipCyc = opts.slipCyc ?? 4;
@@ -4077,6 +4371,10 @@ export {
   SbasProcessor,
   applyOrbitClock,
   hasToOrbitClock,
+  wlWavelength,
+  nlWavelength,
+  resolvePppAmbiguities,
+  fixPppPosition,
   niellMapping,
   gmst,
   sunEcef,
@@ -4086,10 +4384,6 @@ export {
   Sp3EphemerisSource,
   PppEngine,
   solvePpp,
-  wlWavelength,
-  nlWavelength,
-  resolvePppAmbiguities,
-  fixPppPosition,
   extractWidelaneArcs,
   estimateWidelaneFcb,
   estimateNarrowlaneFcb,