@tije-syntra/snap-to-line 0.1.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,3164 @@
+'use strict';
+
+// src/types.ts
+var DirectionOutbound = "outbound";
+var DirectionInbound = "inbound";
+var DirectionLoop = "loop";
+var DirectionUnknown = "unknown";
+function DefaultConfig() {
+  return {
+    MaxSnapDistanceMeter: 60,
+    CandidateLimit: 8,
+    Looping: false,
+    UseBearingValidation: true,
+    MaxBearingDiffDegree: 60,
+    UseMovementBearing: true,
+    MinMovementMeter: 8,
+    UseTripDirection: false,
+    TripDirection: DirectionUnknown,
+    AllowSameStartEndStop: true,
+    LoopClosureToleranceMeter: 10,
+    UseSpeed: true,
+    PreventBackwardTransition: false,
+    MeasureRegressionToleranceMeter: 0,
+    ClampBackwardMinConfidence: 0,
+    ClampDwellSpeedKmh: 0,
+    MeasureAdvanceSlackMeter: 0,
+    SegmentSwitchHysteresisLog: 0,
+    SnappedJumpSlackMeter: 0,
+    HoldLastSegmentOnMiss: false,
+    HoldLastSegmentMaxDistM: 0,
+    HoldLastSegmentMaxAgeMs: 0,
+    HoldLastSegmentMinConfidence: 0,
+    WildGPSStabilize: false,
+    WildGPSJumpMinMeter: 0,
+    WildGPSJumpMultiplier: 0,
+    WildGPSMaxAdvanceFactor: 0,
+    MaxForwardSnapMeter: 0,
+    NoBackwardSnap: false,
+    RequireNextStopBeforeSegmentSwitch: false,
+    NextStopPassToleranceMeter: 0,
+    RequireStopRadiusForSegmentSwitch: false,
+    SegmentSwitchStopRadiusMeter: 0,
+    FoldedSegmentBranchLock: false,
+    FoldedSegmentMinViable: 0,
+    BranchLockSearchWindowM: 0,
+    BranchUnlockNormalTicks: 0,
+    FoldedSegmentMeasureSpreadM: 0,
+    SnapContinuityFromPrevious: false,
+    SnapDistanceResetOnGrow: false,
+    SnapDistanceGrowResetTicks: 0,
+    SnapDistanceGrowMinDeltaM: 0,
+    SnapDistanceResetMinMeter: 0,
+    SnapDistanceResetMaxMeter: 0
+  };
+}
+
+// src/errors.ts
+var SnapToLineError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SnapToLineError";
+  }
+};
+var ErrInsufficientStops = new SnapToLineError(
+  "snaptoline: at least two stops required"
+);
+var ErrInvalidLine = new SnapToLineError(
+  "snaptoline: line must contain at least two points"
+);
+var ErrStopMeasureNotMonotonic = new SnapToLineError(
+  "snaptoline: projected stop measures must be monotonically increasing"
+);
+var ErrInvalidMeasureRange = new SnapToLineError(
+  "snaptoline: invalid measure range"
+);
+var ErrNoCandidates = new SnapToLineError(
+  "snaptoline: no snap candidates found"
+);
+var ErrEmptySegments = new SnapToLineError(
+  "snaptoline: no segments built from stops"
+);
+
+// src/mathgeo/distance.ts
+var EARTH_RADIUS_METER = 63710088e-1;
+function toRad(deg) {
+  return deg * Math.PI / 180;
+}
+function toDeg(rad) {
+  return rad * 180 / Math.PI;
+}
+function distanceMeter(a, b) {
+  const lat1 = toRad(a[1]);
+  const lat2 = toRad(b[1]);
+  const dLat = toRad(b[1] - a[1]);
+  const dLon = toRad(b[0] - a[0]);
+  const sinDLat = Math.sin(dLat / 2);
+  const sinDLon = Math.sin(dLon / 2);
+  const h = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon;
+  return 2 * EARTH_RADIUS_METER * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+
+// src/mathgeo/bearing.ts
+function bearingBetween(a, b) {
+  const lat1 = toRad(a[1]);
+  const lat2 = toRad(b[1]);
+  const dLon = toRad(b[0] - a[0]);
+  const y = Math.sin(dLon) * Math.cos(lat2);
+  const x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
+  let bearing = toDeg(Math.atan2(y, x));
+  if (bearing < 0) {
+    bearing += 360;
+  }
+  return bearing;
+}
+function bearingDiff(a, b) {
+  let diff = Math.abs(a - b);
+  if (diff > 180) {
+    diff = 360 - diff;
+  }
+  return diff;
+}
+
+// src/mathgeo/measure.ts
+var ErrInvalidLine2 = new Error(
+  "mathgeo: line must contain at least two points"
+);
+var ErrInvalidMeasureRange2 = new Error(
+  "mathgeo: invalid measure range"
+);
+function lineLengthMeter(line) {
+  if (line.length < 2) {
+    return 0;
+  }
+  let total = 0;
+  for (let i = 0; i < line.length - 1; i++) {
+    total += distanceMeter(line[i], line[i + 1]);
+  }
+  return total;
+}
+function pointAtMeasure(line, measure) {
+  if (line.length === 0) {
+    return [[0, 0], 0];
+  }
+  if (line.length === 1 || measure <= 0) {
+    return [line[0], 0];
+  }
+  const total = lineLengthMeter(line);
+  if (measure >= total) {
+    return [line[line.length - 1], line.length - 2];
+  }
+  let cumulative = 0;
+  for (let i = 0; i < line.length - 1; i++) {
+    const a = line[i];
+    const b = line[i + 1];
+    const segLen = distanceMeter(a, b);
+    if (cumulative + segLen >= measure) {
+      let t = (measure - cumulative) / segLen;
+      if (t < 0) t = 0;
+      else if (t > 1) t = 1;
+      return [[a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])], i];
+    }
+    cumulative += segLen;
+  }
+  return [line[line.length - 1], line.length - 2];
+}
+function bearingAtMeasure(line, measure) {
+  if (line.length < 2) {
+    return 0;
+  }
+  const total = lineLengthMeter(line);
+  if (measure >= total) {
+    const a2 = line[line.length - 2];
+    const b2 = line[line.length - 1];
+    return bearingBetween(a2, b2);
+  }
+  let cumulative = 0;
+  for (let i = 0; i < line.length - 1; i++) {
+    const a2 = line[i];
+    const b2 = line[i + 1];
+    const segLen = distanceMeter(a2, b2);
+    if (cumulative + segLen >= measure || i === line.length - 2) {
+      return bearingBetween(a2, b2);
+    }
+    cumulative += segLen;
+  }
+  const a = line[line.length - 2];
+  const b = line[line.length - 1];
+  return bearingBetween(a, b);
+}
+function sliceLineByMeasure(line, fromMeasure, toMeasure) {
+  if (line.length < 2) {
+    throw ErrInvalidLine2;
+  }
+  if (toMeasure <= fromMeasure) {
+    throw ErrInvalidMeasureRange2;
+  }
+  const [startPoint, startIdx] = pointAtMeasure(line, fromMeasure);
+  const [endPoint, endIdx] = pointAtMeasure(line, toMeasure);
+  const result = [startPoint];
+  for (let i = startIdx + 1; i <= endIdx && i < line.length; i++) {
+    result.push(line[i]);
+  }
+  const last = result[result.length - 1];
+  if (last[0] !== endPoint[0] || last[1] !== endPoint[1]) {
+    result.push(endPoint);
+  }
+  if (result.length < 2) {
+    throw ErrInvalidMeasureRange2;
+  }
+  return result;
+}
+
+// src/mathgeo/projection.ts
+function projectPointOnSegment(a, b, p) {
+  const ax = a[0];
+  const ay = a[1];
+  const bx = b[0];
+  const by = b[1];
+  const px = p[0];
+  const py = p[1];
+  const dx = bx - ax;
+  const dy = by - ay;
+  if (dx === 0 && dy === 0) {
+    return [a, 0];
+  }
+  let t = ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy);
+  if (t < 0) t = 0;
+  else if (t > 1) t = 1;
+  const projected = [ax + t * dx, ay + t * dy];
+  return [projected, t];
+}
+function findProjectionCandidates(line, point) {
+  if (line.length < 2) {
+    return [];
+  }
+  let cumulative = 0;
+  const candidates = [];
+  for (let i = 0; i < line.length - 1; i++) {
+    const a = line[i];
+    const b = line[i + 1];
+    const segLen = distanceMeter(a, b);
+    const [projected, t] = projectPointOnSegment(a, b, point);
+    const measure = cumulative + segLen * t;
+    candidates.push({
+      Point: projected,
+      Measure: measure,
+      LineIndex: i,
+      DistanceMeter: distanceMeter(point, projected)
+    });
+    cumulative += segLen;
+  }
+  return candidates;
+}
+function findNearestProjectionAfterMeasure(line, point, minMeasure) {
+  const candidates = findProjectionCandidates(line, point);
+  let best = null;
+  for (const c of candidates) {
+    if (c.Measure < minMeasure) {
+      continue;
+    }
+    if (!best || c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  if (best) {
+    return best;
+  }
+  const total = lineLengthMeter(line);
+  const last = line[line.length - 1];
+  return {
+    Point: last,
+    Measure: total,
+    LineIndex: line.length - 2,
+    DistanceMeter: distanceMeter(point, last)
+  };
+}
+function findProjectionNearMeasure(line, point, targetMeasure, searchWindow) {
+  const candidates = findProjectionCandidates(line, point);
+  let best = null;
+  for (const c of candidates) {
+    let delta = c.Measure - targetMeasure;
+    if (delta < 0) delta = -delta;
+    if (searchWindow > 0 && delta > searchWindow) {
+      continue;
+    }
+    if (!best || c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  if (best) {
+    return best;
+  }
+  return findNearestProjectionAfterMeasure(line, point, 0);
+}
+
+// src/geometry.ts
+var DEFAULT_SNAPPED_JUMP_SLACK_METER = 4;
+function DistanceMeter(a, b) {
+  return distanceMeter(a, b);
+}
+function LineLengthMeter(line) {
+  return lineLengthMeter(line);
+}
+function BearingBetween(a, b) {
+  return bearingBetween(a, b);
+}
+function BearingDiff(a, b) {
+  return bearingDiff(a, b);
+}
+function BearingAtMeasure(line, measure) {
+  return bearingAtMeasure(line, measure);
+}
+function SliceLineByMeasure(line, fromMeasure, toMeasure) {
+  try {
+    return sliceLineByMeasure(line, fromMeasure, toMeasure);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("invalid measure range")) {
+      throw ErrInvalidMeasureRange;
+    }
+    throw ErrInvalidLine;
+  }
+}
+function PointAtMeasure(line, measure) {
+  return pointAtMeasure(line, measure);
+}
+function FindProjectionCandidates(line, point) {
+  return findProjectionCandidates(line, point);
+}
+function FindNearestProjectionAfterMeasure(line, point, minMeasure) {
+  return findNearestProjectionAfterMeasure(line, point, minMeasure);
+}
+function FindProjectionNearMeasure(line, point, targetMeasure, searchWindow) {
+  return findProjectionNearMeasure(line, point, targetMeasure, searchWindow);
+}
+function ProjectPointOnLine(line, point) {
+  const candidates = FindProjectionCandidates(line, point);
+  if (candidates.length === 0) {
+    return {
+      Point: [0, 0],
+      Measure: 0,
+      LineIndex: 0,
+      DistanceMeter: 0
+    };
+  }
+  let best = candidates[0];
+  for (const c of candidates.slice(1)) {
+    if (c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  return best;
+}
+function measureDelta(a, b) {
+  const d = a - b;
+  return d < 0 ? -d : d;
+}
+function hasLastSnapped(p) {
+  return p[0] !== 0 || p[1] !== 0;
+}
+function pickMeasureContinuityCandidate(viable, prevRelMeasure, lastSnapped) {
+  let best = viable[0];
+  const useSnapped = hasLastSnapped(lastSnapped);
+  for (const c of viable.slice(1)) {
+    const dBest = measureDelta(best.Measure, prevRelMeasure);
+    const dCand = measureDelta(c.Measure, prevRelMeasure);
+    if (dCand + 1 < dBest) {
+      best = c;
+    } else if (dCand <= dBest + 1 && useSnapped) {
+      if (distanceMeter(lastSnapped, c.Point) < distanceMeter(lastSnapped, best.Point)) {
+        best = c;
+      }
+    } else if (dCand === dBest && !useSnapped && c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  return best;
+}
+function ProjectPointOnLineContinued(line, point, prevRelMeasure, prevPoint, lastSnapped, cfg) {
+  if (prevRelMeasure <= 0) {
+    return ProjectPointOnLine(line, point);
+  }
+  const candidates = FindProjectionCandidates(line, point);
+  const viable = candidates.filter(
+    (c) => c.DistanceMeter <= cfg.MaxSnapDistanceMeter
+  );
+  if (viable.length === 0) {
+    return ProjectPointOnLine(line, point);
+  }
+  if (viable.length === 1) {
+    return viable[0];
+  }
+  let tol = cfg.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = 30;
+  }
+  const best = pickMeasureContinuityCandidate(
+    viable,
+    prevRelMeasure,
+    lastSnapped
+  );
+  const nearest = ProjectPointOnLine(line, point);
+  if (nearest.Measure < prevRelMeasure - tol && measureDelta(best.Measure, prevRelMeasure) + 5 < measureDelta(nearest.Measure, prevRelMeasure)) {
+    return best;
+  }
+  let jumpSlack = cfg.SnappedJumpSlackMeter;
+  if (jumpSlack <= 0) {
+    jumpSlack = DEFAULT_SNAPPED_JUMP_SLACK_METER;
+  }
+  let movement = 0;
+  if (prevPoint) {
+    movement = distanceMeter(prevPoint.Point, point);
+  }
+  let minMovement = cfg.MinMovementMeter;
+  if (minMovement <= 0) {
+    minMovement = 1;
+  }
+  if (prevPoint && movement < minMovement && hasLastSnapped(lastSnapped)) {
+    return best;
+  }
+  if (hasLastSnapped(lastSnapped)) {
+    if (movement < 1) {
+      movement = 1;
+    }
+    const jumpNearest = distanceMeter(lastSnapped, nearest.Point);
+    const jumpBest = distanceMeter(lastSnapped, best.Point);
+    if (jumpNearest > movement * 0.75 + jumpSlack && jumpBest < jumpNearest) {
+      return best;
+    }
+    if (jumpNearest > jumpSlack && jumpBest <= jumpSlack) {
+      return best;
+    }
+    const dBest = measureDelta(best.Measure, prevRelMeasure);
+    const dNearest = measureDelta(nearest.Measure, prevRelMeasure);
+    if (dBest <= dNearest + tol / 2 && jumpBest <= jumpNearest) {
+      return best;
+    }
+  }
+  if (measureDelta(best.Measure, prevRelMeasure) + 1 < measureDelta(nearest.Measure, prevRelMeasure)) {
+    return best;
+  }
+  return nearest;
+}
+function ForwardProjectionOnSegment(line, point, minRelMeasure, maxRelMeasure, maxDist) {
+  if (line.length < 2) {
+    return [
+      { Point: [0, 0], Measure: 0, LineIndex: 0, DistanceMeter: 0 },
+      false
+    ];
+  }
+  const cands = FindProjectionCandidates(line, point);
+  let best = null;
+  for (const c of cands) {
+    if (c.DistanceMeter > maxDist) continue;
+    if (c.Measure < minRelMeasure || c.Measure > maxRelMeasure) continue;
+    if (!best || c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  if (!best) {
+    return [
+      { Point: [0, 0], Measure: 0, LineIndex: 0, DistanceMeter: 0 },
+      false
+    ];
+  }
+  return [best, true];
+}
+function nearestStopID(stops, point) {
+  if (stops.length === 0) {
+    return "";
+  }
+  let best = stops[0];
+  let bestDist = distanceMeter(point, best.Point);
+  for (const stop of stops.slice(1)) {
+    const d = distanceMeter(point, stop.Point);
+    if (d < bestDist) {
+      best = stop;
+      bestDist = d;
+    }
+  }
+  return best.ID;
+}
+function segmentProgress(seg, measure) {
+  const length = seg.ToMeasure - seg.FromMeasure;
+  if (length <= 0) {
+    return 0;
+  }
+  return (measure - seg.FromMeasure) / length;
+}
+
+// src/loop.ts
+function IsSameStop(a, b, toleranceMeter) {
+  if (a.ID !== b.ID) {
+    return false;
+  }
+  return DistanceMeter(a.Point, b.Point) <= toleranceMeter;
+}
+function sortStopsByOrder(stops) {
+  return [...stops].sort((a, b) => a.Order - b.Order);
+}
+function CountOccurrence(projected, stopID) {
+  let count = 0;
+  for (const p of projected) {
+    if (p.Stop.ID === stopID) {
+      count++;
+    }
+  }
+  return count;
+}
+function ProjectStopNearMeasure(line, stop, targetMeasure, _cfg) {
+  const total = LineLengthMeter(line);
+  let window = total * 0.15;
+  if (window < 50) window = 50;
+  if (window > 500) window = 500;
+  const candidate = FindProjectionNearMeasure(
+    line,
+    stop.Point,
+    targetMeasure,
+    window
+  );
+  return {
+    Stop: stop,
+    Measure: candidate.Measure,
+    LineIndex: candidate.LineIndex,
+    Occurrence: 0
+  };
+}
+function ProjectStopForwardOnly(line, stop, minMeasure, _cfg) {
+  const candidates = FindProjectionCandidates(line, stop.Point);
+  let best = null;
+  for (const c of candidates) {
+    if (c.Measure < minMeasure) continue;
+    if (!best || c.DistanceMeter < best.DistanceMeter) {
+      best = c;
+    }
+  }
+  if (!best) {
+    best = FindNearestProjectionAfterMeasure(line, stop.Point, minMeasure);
+  }
+  return {
+    Stop: stop,
+    Measure: best.Measure,
+    LineIndex: best.LineIndex,
+    Occurrence: 0
+  };
+}
+function ProjectStopsSequential(line, stops, cfg) {
+  if (stops.length < 2) {
+    throw ErrInsufficientStops;
+  }
+  if (line.length < 2) {
+    throw ErrInvalidLine;
+  }
+  const sorted = sortStopsByOrder(stops);
+  const totalLength = LineLengthMeter(line);
+  const result = [];
+  const firstStop = sorted[0];
+  const lastStop = sorted[sorted.length - 1];
+  const isClosedLoopStop = cfg.Looping && cfg.AllowSameStartEndStop && IsSameStop(firstStop, lastStop, cfg.LoopClosureToleranceMeter);
+  let lastMeasure = 0;
+  for (let i = 0; i < sorted.length; i++) {
+    const stop = sorted[i];
+    let projected;
+    if (i === 0) {
+      projected = ProjectStopNearMeasure(line, stop, 0);
+      projected.Measure = 0;
+      projected.Occurrence = 1;
+    } else if (isClosedLoopStop && i === sorted.length - 1) {
+      projected = ProjectStopNearMeasure(line, stop, totalLength);
+      projected.Measure = totalLength;
+      projected.Occurrence = 2;
+      projected.IsLoopClosure = true;
+    } else {
+      projected = ProjectStopForwardOnly(line, stop, lastMeasure);
+      projected.Occurrence = CountOccurrence(result, stop.ID) + 1;
+    }
+    if (projected.Measure < lastMeasure) {
+      throw ErrStopMeasureNotMonotonic;
+    }
+    result.push(projected);
+    lastMeasure = projected.Measure;
+  }
+  return result;
+}
+function DetectLoopClosure(projected) {
+  if (projected.length < 2) {
+    return false;
+  }
+  return !!projected[projected.length - 1].IsLoopClosure;
+}
+function segmentID(from, to, order) {
+  return `SEG-${from.ID}-${to.ID}-${order}`;
+}
+function detectLoopFromStops(stops, allowSame, toleranceM) {
+  if (!allowSame) {
+    return false;
+  }
+  const sorted = sortStopsByOrder(stops);
+  if (sorted.length < 2) {
+    return false;
+  }
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  return IsSameStop(first, last, toleranceM);
+}
+
+// src/segment.ts
+function resolveSegmentDirection(cfg, _isLoopClosure, segmentIndex) {
+  if (segmentIndex >= 0 && cfg.SegmentDirections && segmentIndex < cfg.SegmentDirections.length) {
+    const dir = cfg.SegmentDirections[segmentIndex];
+    if (dir && dir !== "unknown") {
+      return dir;
+    }
+  }
+  if (cfg.Looping) {
+    return "loop";
+  }
+  if (cfg.UseTripDirection && cfg.TripDirection !== "unknown") {
+    return cfg.TripDirection;
+  }
+  return "unknown";
+}
+function BuildSegmentsFromProjectedStops(line, projectedStops, cfg) {
+  if (projectedStops.length < 2) {
+    throw ErrInsufficientStops;
+  }
+  const segments = [];
+  const totalLength = LineLengthMeter(line);
+  for (let i = 0; i < projectedStops.length - 1; i++) {
+    const from = projectedStops[i];
+    const to = projectedStops[i + 1];
+    const fromMeasure = from.Measure;
+    const toMeasure = to.Measure;
+    if (toMeasure <= fromMeasure) {
+      throw ErrInvalidMeasureRange;
+    }
+    const geometry = SliceLineByMeasure(line, fromMeasure, toMeasure);
+    let bearing = BearingAtMeasure(geometry, 0);
+    if (geometry.length >= 2) {
+      bearing = BearingBetween(geometry[0], geometry[geometry.length - 1]);
+    }
+    const direction = resolveSegmentDirection(cfg, !!to.IsLoopClosure, i);
+    segments.push({
+      ID: segmentID(from.Stop, to.Stop, i + 1),
+      FromStop: from.Stop,
+      ToStop: to.Stop,
+      FromMeasure: fromMeasure,
+      ToMeasure: toMeasure,
+      Geometry: geometry,
+      Order: i + 1,
+      Direction: direction,
+      Bearing: bearing,
+      IsLooping: cfg.Looping,
+      IsLoopClosing: !!to.IsLoopClosure
+    });
+  }
+  if (cfg.Looping && segments.length > 0) {
+    const last = segments[segments.length - 1];
+    if (last.ToMeasure < totalLength * 0.95 && projectedStops[projectedStops.length - 1].IsLoopClosure) {
+      throw new Error(
+        "snaptoline: loop closing segment must reach end of line"
+      );
+    }
+  }
+  return segments;
+}
+function BuildSegments(line, stops, cfg) {
+  const projected = ProjectStopsSequential(line, stops, cfg);
+  return BuildSegmentsFromProjectedStops(line, projected, cfg);
+}
+function segmentWithOrder(segments, order) {
+  for (const seg of segments) {
+    if (seg.Order === order) {
+      return [seg, true];
+    }
+  }
+  return [
+    {
+      ID: "",
+      FromStop: { ID: "", Point: [0, 0], Order: 0 },
+      ToStop: { ID: "", Point: [0, 0], Order: 0 },
+      FromMeasure: 0,
+      ToMeasure: 0,
+      Geometry: [],
+      Order: 0,
+      Direction: "unknown",
+      Bearing: 0,
+      IsLooping: false,
+      IsLoopClosing: false
+    },
+    false
+  ];
+}
+
+// src/direction.ts
+function DirectionScore(diff, maxDiff) {
+  if (maxDiff <= 0) {
+    return 1;
+  }
+  if (diff > maxDiff) {
+    return 0.05;
+  }
+  return 1 - diff / maxDiff;
+}
+function TripDirectionScore(candidate, active) {
+  if (active === "unknown") {
+    return 1;
+  }
+  if (candidate === active) {
+    return 1;
+  }
+  if (candidate === "loop") {
+    return 0.7;
+  }
+  return 0.05;
+}
+function EmissionScore(distanceMeter2, maxDistance) {
+  if (maxDistance <= 0) {
+    return 0.05;
+  }
+  if (distanceMeter2 > maxDistance) {
+    return 0.05;
+  }
+  const ratio = distanceMeter2 / maxDistance;
+  const score = 1 - ratio;
+  if (score < 0.05) {
+    return 0.05;
+  }
+  return score;
+}
+function resolveBusBearing(point, prev, cfg) {
+  if (point.Bearing != null && point.Bearing > 0) {
+    return [point.Bearing, true];
+  }
+  if (!prev || !cfg.UseMovementBearing) {
+    return [0, false];
+  }
+  const movement = distanceMeter(prev.Point, point.Point);
+  if (movement < cfg.MinMovementMeter) {
+    return [0, false];
+  }
+  return [bearingBetween(prev.Point, point.Point), true];
+}
+function shouldWeakenDirectionValidation(point, prev, cfg) {
+  const lowSpeedKmh = 3;
+  if (cfg.UseSpeed && (point.Speed ?? 0) < lowSpeedKmh) {
+    return true;
+  }
+  if (prev && cfg.UseMovementBearing) {
+    const movement = distanceMeter(prev.Point, point.Point);
+    if (movement < cfg.MinMovementMeter) {
+      return true;
+    }
+  }
+  return false;
+}
+function scoreDirection(busBearing, hasBearing, lineBearing, cfg, weaken) {
+  if (!cfg.UseBearingValidation || !hasBearing) {
+    return [1, 0];
+  }
+  const diff = bearingDiff(busBearing, lineBearing);
+  let score = DirectionScore(diff, cfg.MaxBearingDiffDegree);
+  if (weaken && score < 0.7) {
+    score = 0.7;
+  }
+  return [score, diff];
+}
+function logScore(score) {
+  if (score <= 0) {
+    return Math.log(0.05);
+  }
+  return Math.log(score);
+}
+function clampConfidence(v) {
+  return Math.max(0, Math.min(1, v));
+}
+function confidenceFromScores(c) {
+  const score = c.EmissionScore * c.DirectionScore * c.TripDirectionScore;
+  if (score > 1) return 1;
+  if (score < 0) return 0;
+  return score;
+}
+function bearingDiffDeg(a, b) {
+  let d = (a - b + 540) % 360 - 180;
+  if (d < 0) d = -d;
+  return d;
+}
+
+// src/config-route.ts
+var DefaultRouteMeasureRegressionToleranceMeter = 30;
+var DefaultRouteClampBackwardMinConfidence = 0.55;
+var DefaultRouteClampDwellSpeedKmh = 8;
+var DefaultRouteMeasureAdvanceSlackMeter = 15;
+var DefaultRouteSegmentSwitchHysteresisLog = 1;
+var DefaultRouteSnappedJumpSlackMeter = 4;
+var DefaultRouteHoldLastSegmentMaxDistM = 120;
+var DefaultRouteHoldLastSegmentMaxAgeMs = 3e4;
+var DefaultRouteHoldLastSegmentMinConfidence = 0.25;
+var DefaultRouteWildGPSJumpMinMeter = 25;
+var DefaultRouteWildGPSJumpMultiplier = 2;
+var DefaultRouteWildGPSMaxAdvanceFactor = 0.5;
+var DefaultRouteMaxForwardSnapMeter = 0;
+var DefaultRouteNextStopPassToleranceMeter = 8;
+var DefaultRouteSegmentSwitchStopRadiusMeter = 20;
+var DefaultFoldedSegmentMinViable = 3;
+var DefaultBranchLockSearchWindowM = 20;
+var DefaultBranchUnlockNormalTicks = 3;
+var DefaultFoldedSegmentMeasureSpreadM = 45;
+var DefaultSnapDistanceGrowResetTicks = 2;
+var DefaultSnapDistanceGrowMinDeltaM = 8;
+var DefaultSnapDistanceResetMinMeter = 35;
+var DefaultSnapDistanceResetMaxMeter = 100;
+function RouteSnapParamsOption(p) {
+  return (acc) => {
+    Object.assign(acc, mergeRouteSnapParams(acc, p));
+  };
+}
+function WithRouteSnapParams(p) {
+  return RouteSnapParamsOption(p);
+}
+function WithPreventBackwardTransition(v) {
+  return (p) => {
+    p.PreventBackwardTransition = v;
+  };
+}
+function WithMeasureRegressionTolerance(m) {
+  return (p) => {
+    p.MeasureRegressionToleranceMeter = m;
+  };
+}
+function WithClampBackwardMinConfidence(v) {
+  return (p) => {
+    p.ClampBackwardMinConfidence = v;
+  };
+}
+function WithClampDwellSpeedKmh(kmh) {
+  return (p) => {
+    p.ClampDwellSpeedKmh = kmh;
+  };
+}
+function WithMeasureAdvanceSlack(m) {
+  return (p) => {
+    p.MeasureAdvanceSlackMeter = m;
+  };
+}
+function WithSnappedJumpSlack(m) {
+  return (p) => {
+    p.SnappedJumpSlackMeter = m;
+  };
+}
+function WithSegmentSwitchHysteresisLog(v) {
+  return (p) => {
+    p.SegmentSwitchHysteresisLog = v;
+  };
+}
+function WithLooping(v) {
+  return (p) => {
+    p.Looping = v;
+  };
+}
+function WithLoopClosureTolerance(m) {
+  return (p) => {
+    p.LoopClosureToleranceMeter = m;
+  };
+}
+function WithHoldLastSegmentOnMiss(v) {
+  return (p) => {
+    p.HoldLastSegmentOnMiss = v;
+  };
+}
+function WithHoldLastSegmentMaxDistM(m) {
+  return (p) => {
+    p.HoldLastSegmentMaxDistM = m;
+  };
+}
+function WithHoldLastSegmentMaxAgeMs(ms) {
+  return (p) => {
+    p.HoldLastSegmentMaxAgeMs = ms;
+  };
+}
+function WithHoldLastSegmentMinConfidence(v) {
+  return (p) => {
+    p.HoldLastSegmentMinConfidence = v;
+  };
+}
+function WithWildGPSStabilize(v) {
+  return (p) => {
+    p.WildGPSStabilize = v;
+  };
+}
+function WithWildGPSJumpMinMeter(m) {
+  return (p) => {
+    p.WildGPSJumpMinMeter = m;
+  };
+}
+function WithWildGPSJumpMultiplier(v) {
+  return (p) => {
+    p.WildGPSJumpMultiplier = v;
+  };
+}
+function WithWildGPSMaxAdvanceFactor(v) {
+  return (p) => {
+    p.WildGPSMaxAdvanceFactor = v;
+  };
+}
+function WithMaxForwardSnapMeter(m) {
+  return (p) => {
+    p.MaxForwardSnapMeter = m;
+  };
+}
+function WithNoBackwardSnap(v) {
+  return (p) => {
+    p.NoBackwardSnap = v;
+  };
+}
+function WithRequireNextStopBeforeSegmentSwitch(v) {
+  return (p) => {
+    p.RequireNextStopBeforeSegmentSwitch = v;
+  };
+}
+function WithNextStopPassToleranceMeter(m) {
+  return (p) => {
+    p.NextStopPassToleranceMeter = m;
+  };
+}
+function WithRequireStopRadiusForSegmentSwitch(v) {
+  return (p) => {
+    p.RequireStopRadiusForSegmentSwitch = v;
+  };
+}
+function WithSegmentSwitchStopRadiusMeter(m) {
+  return (p) => {
+    p.SegmentSwitchStopRadiusMeter = m;
+  };
+}
+function WithFoldedSegmentBranchLock(v) {
+  return (p) => {
+    p.FoldedSegmentBranchLock = v;
+  };
+}
+function WithFoldedSegmentMinViable(n) {
+  return (p) => {
+    p.FoldedSegmentMinViable = n;
+  };
+}
+function WithBranchLockSearchWindowM(m) {
+  return (p) => {
+    p.BranchLockSearchWindowM = m;
+  };
+}
+function WithBranchUnlockNormalTicks(n) {
+  return (p) => {
+    p.BranchUnlockNormalTicks = n;
+  };
+}
+function WithFoldedSegmentMeasureSpreadM(m) {
+  return (p) => {
+    p.FoldedSegmentMeasureSpreadM = m;
+  };
+}
+function WithSnapContinuityFromPrevious(v) {
+  return (p) => {
+    p.SnapContinuityFromPrevious = v;
+  };
+}
+function WithSnapDistanceResetOnGrow(v) {
+  return (p) => {
+    p.SnapDistanceResetOnGrow = v;
+  };
+}
+function WithSnapDistanceGrowResetTicks(n) {
+  return (p) => {
+    p.SnapDistanceGrowResetTicks = n;
+  };
+}
+function WithSnapDistanceGrowMinDeltaM(m) {
+  return (p) => {
+    p.SnapDistanceGrowMinDeltaM = m;
+  };
+}
+function WithSnapDistanceResetMinMeter(m) {
+  return (p) => {
+    p.SnapDistanceResetMinMeter = m;
+  };
+}
+function WithSnapDistanceResetMaxMeter(m) {
+  return (p) => {
+    p.SnapDistanceResetMaxMeter = m;
+  };
+}
+function DisableBackwardClamp() {
+  return (p) => {
+    p.ClampBackwardMinConfidence = 0;
+  };
+}
+function RouteSnapConfig(stops, ...opts) {
+  const params = {};
+  for (const opt of opts) {
+    if (opt) {
+      opt(params);
+    }
+  }
+  return routeSnapConfig(stops, params);
+}
+function routeSnapConfig(stops, params) {
+  const cfg = DefaultConfig();
+  cfg.PreventBackwardTransition = params.PreventBackwardTransition ?? true;
+  cfg.MeasureRegressionToleranceMeter = params.MeasureRegressionToleranceMeter ?? DefaultRouteMeasureRegressionToleranceMeter;
+  cfg.ClampBackwardMinConfidence = params.ClampBackwardMinConfidence ?? DefaultRouteClampBackwardMinConfidence;
+  cfg.ClampDwellSpeedKmh = params.ClampDwellSpeedKmh ?? DefaultRouteClampDwellSpeedKmh;
+  cfg.MeasureAdvanceSlackMeter = params.MeasureAdvanceSlackMeter ?? DefaultRouteMeasureAdvanceSlackMeter;
+  cfg.SegmentSwitchHysteresisLog = params.SegmentSwitchHysteresisLog ?? DefaultRouteSegmentSwitchHysteresisLog;
+  cfg.SnappedJumpSlackMeter = params.SnappedJumpSlackMeter ?? DefaultRouteSnappedJumpSlackMeter;
+  let loopTol = cfg.LoopClosureToleranceMeter;
+  if (params.LoopClosureToleranceMeter != null) {
+    loopTol = params.LoopClosureToleranceMeter;
+    cfg.LoopClosureToleranceMeter = loopTol;
+  }
+  if (params.Looping != null) {
+    cfg.Looping = params.Looping;
+  } else {
+    cfg.Looping = detectLoopFromStops(
+      stops,
+      cfg.AllowSameStartEndStop,
+      loopTol
+    );
+  }
+  cfg.HoldLastSegmentOnMiss = params.HoldLastSegmentOnMiss ?? true;
+  cfg.HoldLastSegmentMaxDistM = params.HoldLastSegmentMaxDistM ?? DefaultRouteHoldLastSegmentMaxDistM;
+  cfg.HoldLastSegmentMaxAgeMs = params.HoldLastSegmentMaxAgeMs ?? DefaultRouteHoldLastSegmentMaxAgeMs;
+  cfg.HoldLastSegmentMinConfidence = params.HoldLastSegmentMinConfidence ?? DefaultRouteHoldLastSegmentMinConfidence;
+  cfg.WildGPSStabilize = params.WildGPSStabilize ?? true;
+  cfg.WildGPSJumpMinMeter = params.WildGPSJumpMinMeter ?? DefaultRouteWildGPSJumpMinMeter;
+  cfg.WildGPSJumpMultiplier = params.WildGPSJumpMultiplier ?? DefaultRouteWildGPSJumpMultiplier;
+  cfg.WildGPSMaxAdvanceFactor = params.WildGPSMaxAdvanceFactor ?? DefaultRouteWildGPSMaxAdvanceFactor;
+  cfg.MaxForwardSnapMeter = params.MaxForwardSnapMeter ?? DefaultRouteMaxForwardSnapMeter;
+  cfg.NoBackwardSnap = params.NoBackwardSnap ?? true;
+  cfg.RequireNextStopBeforeSegmentSwitch = params.RequireNextStopBeforeSegmentSwitch ?? true;
+  cfg.NextStopPassToleranceMeter = params.NextStopPassToleranceMeter ?? DefaultRouteNextStopPassToleranceMeter;
+  cfg.RequireStopRadiusForSegmentSwitch = params.RequireStopRadiusForSegmentSwitch ?? true;
+  cfg.SegmentSwitchStopRadiusMeter = params.SegmentSwitchStopRadiusMeter ?? DefaultRouteSegmentSwitchStopRadiusMeter;
+  cfg.FoldedSegmentBranchLock = params.FoldedSegmentBranchLock ?? true;
+  cfg.FoldedSegmentMinViable = params.FoldedSegmentMinViable ?? DefaultFoldedSegmentMinViable;
+  cfg.BranchLockSearchWindowM = params.BranchLockSearchWindowM ?? DefaultBranchLockSearchWindowM;
+  cfg.BranchUnlockNormalTicks = params.BranchUnlockNormalTicks ?? DefaultBranchUnlockNormalTicks;
+  cfg.FoldedSegmentMeasureSpreadM = params.FoldedSegmentMeasureSpreadM ?? DefaultFoldedSegmentMeasureSpreadM;
+  cfg.SnapContinuityFromPrevious = params.SnapContinuityFromPrevious ?? true;
+  cfg.SnapDistanceResetOnGrow = params.SnapDistanceResetOnGrow ?? true;
+  cfg.SnapDistanceGrowResetTicks = params.SnapDistanceGrowResetTicks ?? DefaultSnapDistanceGrowResetTicks;
+  cfg.SnapDistanceGrowMinDeltaM = params.SnapDistanceGrowMinDeltaM ?? DefaultSnapDistanceGrowMinDeltaM;
+  cfg.SnapDistanceResetMinMeter = params.SnapDistanceResetMinMeter ?? DefaultSnapDistanceResetMinMeter;
+  cfg.SnapDistanceResetMaxMeter = params.SnapDistanceResetMaxMeter ?? DefaultSnapDistanceResetMaxMeter;
+  return cfg;
+}
+function mergeRouteSnapParams(base, override) {
+  const out = { ...base };
+  for (const key of Object.keys(override)) {
+    if (override[key] !== void 0) {
+      out[key] = override[key];
+    }
+  }
+  return out;
+}
+
+// src/segment-switch.ts
+function isLoopWrapTransition(fromOrder, toOrder, segmentCount, looping) {
+  if (!looping || segmentCount <= 0) {
+    return false;
+  }
+  return fromOrder === segmentCount && toOrder === 1;
+}
+function nextStopPassTolerance(cfg) {
+  let tol = cfg.NextStopPassToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteNextStopPassToleranceMeter;
+  }
+  return tol;
+}
+function segmentSwitchStopRadius(cfg) {
+  let r = cfg.SegmentSwitchStopRadiusMeter;
+  if (r <= 0) {
+    r = DefaultRouteSegmentSwitchStopRadiusMeter;
+  }
+  return r;
+}
+function isSegmentOrderChange(state, c) {
+  if (!state?.LastBest) {
+    return false;
+  }
+  return state.LastBest.Segment.ID !== c.Segment.ID;
+}
+function segmentSwitchGateStop(from, to) {
+  if (from.ToStop.ID) {
+    return [from.ToStop.Point, true];
+  }
+  if (to.FromStop.ID) {
+    return [to.FromStop.Point, true];
+  }
+  return [[0, 0], false];
+}
+function forwardDepartLatchActive(state, fromOrder) {
+  if (!state) {
+    return false;
+  }
+  const latch = state.SegmentDepart;
+  return latch.HasDeparted && latch.GateSegmentOrder === fromOrder;
+}
+function updateSegmentDepartLatch(state, point, cfg) {
+  if (!state.LastBest || !cfg.RequireStopRadiusForSegmentSwitch) {
+    return;
+  }
+  const from = state.LastBest.Segment;
+  if (from.Order <= 0) {
+    return;
+  }
+  let latch = { ...state.SegmentDepart };
+  if (latch.GateSegmentOrder !== from.Order) {
+    latch = {
+      GateSegmentOrder: from.Order,
+      WasInsideRadius: false,
+      HasDeparted: false
+    };
+  }
+  if (!from.ToStop.ID) {
+    state.SegmentDepart = latch;
+    return;
+  }
+  const gate = from.ToStop.Point;
+  const radius = segmentSwitchStopRadius(cfg);
+  const dist = DistanceMeter(point.Point, gate);
+  if (dist <= radius) {
+    latch.WasInsideRadius = true;
+    latch.HasDeparted = false;
+  } else if (latch.WasInsideRadius) {
+    const departMeasure = departingSegmentMeasure(state, from, point);
+    if (hasPassedSegmentDestination(departMeasure, from, cfg)) {
+      latch.HasDeparted = true;
+    }
+  }
+  state.SegmentDepart = latch;
+}
+function rejectSegmentSwitchOutsideStopRadius(state, c, segmentCount, point, cfg) {
+  if (!cfg.RequireStopRadiusForSegmentSwitch || !isSegmentOrderChange(state, c)) {
+    return false;
+  }
+  const from = state.LastBest.Segment;
+  const to = c.Segment;
+  const looping = cfg.Looping;
+  const fromOrder = from.Order;
+  const toOrder = to.Order;
+  const loopWrap = isLoopWrapTransition(
+    fromOrder,
+    toOrder,
+    segmentCount,
+    looping
+  );
+  if (toOrder < fromOrder && !loopWrap) {
+    return false;
+  }
+  if (toOrder > fromOrder + 1 && !loopWrap) {
+    return true;
+  }
+  const [gate, ok] = segmentSwitchGateStop(from, to);
+  if (!ok) {
+    return true;
+  }
+  const radius = segmentSwitchStopRadius(cfg);
+  if (DistanceMeter(point.Point, gate) <= radius) {
+    return false;
+  }
+  if (toOrder === fromOrder + 1 && !loopWrap && forwardDepartLatchActive(state, fromOrder)) {
+    return false;
+  }
+  return true;
+}
+function hasPassedSegmentDestination(measure, seg, cfg) {
+  return measure >= seg.ToMeasure - nextStopPassTolerance(cfg);
+}
+function departingSegmentMeasure(state, seg, point) {
+  let measure = seg.FromMeasure;
+  if (state?.LastBest && state.LastBest.Segment.Order === seg.Order) {
+    if (state.LastBest.Measure > measure) {
+      measure = state.LastBest.Measure;
+    }
+  }
+  const proj = ProjectPointOnLine(seg.Geometry, point.Point);
+  const candidate = seg.FromMeasure + proj.Measure;
+  if (candidate > measure) {
+    return candidate;
+  }
+  return measure;
+}
+function rejectPrematureSegmentSwitch(state, c, segmentCount, point, cfg) {
+  if (!cfg.RequireNextStopBeforeSegmentSwitch || !state.LastBest) {
+    return false;
+  }
+  const from = state.LastBest.Segment;
+  const to = c.Segment;
+  if (from.ID === to.ID) {
+    return false;
+  }
+  const looping = cfg.Looping;
+  const fromOrder = from.Order;
+  const toOrder = to.Order;
+  const loopWrap = isLoopWrapTransition(
+    fromOrder,
+    toOrder,
+    segmentCount,
+    looping
+  );
+  if (toOrder < fromOrder && !loopWrap) {
+    return false;
+  }
+  const departMeasure = departingSegmentMeasure(state, from, point);
+  if (!hasPassedSegmentDestination(departMeasure, from, cfg)) {
+    return true;
+  }
+  if (loopWrap) {
+    return false;
+  }
+  if (toOrder > fromOrder + 1) {
+    return true;
+  }
+  return false;
+}
+function rejectSegmentSwitch(state, c, segmentCount, point, cfg) {
+  if (!isSegmentOrderChange(state, c)) {
+    return false;
+  }
+  if (cfg.RequireStopRadiusForSegmentSwitch && rejectSegmentSwitchOutsideStopRadius(
+    state,
+    c,
+    segmentCount,
+    point,
+    cfg
+  )) {
+    return true;
+  }
+  if (cfg.RequireNextStopBeforeSegmentSwitch && rejectPrematureSegmentSwitch(state, c, segmentCount, point, cfg)) {
+    return true;
+  }
+  return false;
+}
+
+// src/viterbi.ts
+function NewViterbiState(activeDirection) {
+  return {
+    LastCandidates: [],
+    LastBest: null,
+    LastGood: null,
+    LastPoint: null,
+    LastTimestamp: 0,
+    ActiveDirection: activeDirection,
+    BranchLock: null,
+    BranchNormalTicks: 0,
+    RecentBranchTicks: [],
+    LastOutputSnapDistanceM: 0,
+    GrowingSnapDistTicks: 0,
+    SegmentDepart: {
+      GateSegmentOrder: 0,
+      WasInsideRadius: false,
+      HasDeparted: false
+    }
+  };
+}
+function TransitionScore(fromOrder, toOrder, segmentCount, looping) {
+  if (segmentCount === 0) {
+    return 0.05;
+  }
+  const fromIdx = fromOrder - 1;
+  const toIdx = toOrder - 1;
+  if (fromIdx === toIdx) {
+    return 1;
+  }
+  if (looping && fromIdx === segmentCount - 1 && toIdx === 0) {
+    return 0.95;
+  }
+  const diff = toIdx - fromIdx;
+  switch (true) {
+    case diff === 1:
+      return 0.95;
+    case diff === 2:
+      return 0.5;
+    case diff === -1:
+      return 0.15;
+    case diff < 0:
+      return 0.05;
+    case diff > 2:
+      return 0.1;
+    default:
+      return 0.3;
+  }
+}
+function projectOntoSegment(seg, point, prev, state, cfg) {
+  let prevRel = 0;
+  let lastSnapped = [0, 0];
+  const hasLast = state?.LastBest != null;
+  if (hasLast && state.LastBest.Segment.Order === seg.Order) {
+    prevRel = state.LastBest.Measure - seg.FromMeasure;
+    lastSnapped = state.LastBest.SnappedPoint;
+  }
+  return ProjectPointOnLineContinued(
+    seg.Geometry,
+    point.Point,
+    prevRel,
+    prev,
+    lastSnapped,
+    cfg
+  );
+}
+function findCandidates(segments, point, prev, state, cfg) {
+  const raw = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const proj = projectOntoSegment(seg, point, prev, state, cfg);
+    if (proj.DistanceMeter > cfg.MaxSnapDistanceMeter) {
+      continue;
+    }
+    const absMeasure = seg.FromMeasure + proj.Measure;
+    raw.push({
+      segmentIndex: i,
+      projection: {
+        Point: proj.Point,
+        Measure: absMeasure,
+        LineIndex: proj.LineIndex,
+        DistanceMeter: proj.DistanceMeter
+      }
+    });
+  }
+  raw.sort(
+    (a, b) => a.projection.DistanceMeter - b.projection.DistanceMeter
+  );
+  if (cfg.CandidateLimit > 0 && raw.length > cfg.CandidateLimit) {
+    raw.splice(cfg.CandidateLimit);
+  }
+  const [busBearing, hasBearing] = resolveBusBearing(point, prev, cfg);
+  const weaken = shouldWeakenDirectionValidation(point, prev, cfg);
+  let activeTrip = cfg.TripDirection;
+  if (!cfg.UseTripDirection) {
+    activeTrip = DirectionUnknown;
+  }
+  const candidates = [];
+  for (const item of raw) {
+    const seg = segments[item.segmentIndex];
+    const lineBearing = BearingAtMeasure(
+      seg.Geometry,
+      item.projection.Measure - seg.FromMeasure
+    );
+    const emission = EmissionScore(
+      item.projection.DistanceMeter,
+      cfg.MaxSnapDistanceMeter
+    );
+    const [dirScore] = scoreDirection(
+      busBearing,
+      hasBearing,
+      lineBearing,
+      cfg,
+      weaken
+    );
+    const tripScore = TripDirectionScore(seg.Direction, activeTrip);
+    candidates.push({
+      SegmentIndex: item.segmentIndex,
+      Segment: seg,
+      Measure: item.projection.Measure,
+      SnappedPoint: item.projection.Point,
+      DistanceMeter: item.projection.DistanceMeter,
+      LineBearing: lineBearing,
+      EmissionScore: emission,
+      DirectionScore: dirScore,
+      TripDirectionScore: tripScore
+    });
+  }
+  return candidates;
+}
+function rejectBackwardCandidate(state, c, segmentCount, point, cfg) {
+  if (!state.LastBest || !cfg.PreventBackwardTransition) {
+    return false;
+  }
+  const fromOrder = state.LastBest.Segment.Order;
+  const toOrder = c.Segment.Order;
+  const looping = cfg.Looping;
+  const loopWrap = isLoopWrapTransition(
+    fromOrder,
+    toOrder,
+    segmentCount,
+    looping
+  );
+  if (toOrder < fromOrder && !loopWrap) {
+    return true;
+  }
+  const tol = cfg.MeasureRegressionToleranceMeter;
+  if (tol > 0 && c.Measure < state.LastBest.Measure - tol && !loopWrap) {
+    return true;
+  }
+  const slack = cfg.MeasureAdvanceSlackMeter;
+  if (slack > 0 && state.LastPoint && !loopWrap) {
+    const movement = DistanceMeter(state.LastPoint.Point, point.Point);
+    if (movement >= cfg.MinMovementMeter) {
+      const maxAdvance = movement * 3 + slack;
+      if (c.Measure > state.LastBest.Measure + maxAdvance) {
+        return true;
+      }
+    }
+  }
+  const jumpSlack = cfg.SnappedJumpSlackMeter;
+  if (jumpSlack > 0 && state.LastPoint && c.Segment.Order === state.LastBest.Segment.Order) {
+    const jump = DistanceMeter(
+      state.LastBest.SnappedPoint,
+      c.SnappedPoint
+    );
+    let movement = DistanceMeter(state.LastPoint.Point, point.Point);
+    if (movement < 1) {
+      movement = 1;
+    }
+    if (jump > movement * 0.75 + jumpSlack) {
+      return true;
+    }
+  }
+  return false;
+}
+function viterbiTotalScore(state, c, segmentCount, cfg) {
+  const emissionLog = logScore(c.EmissionScore);
+  const directionLog = logScore(c.DirectionScore);
+  const tripLog = logScore(c.TripDirectionScore);
+  const stepLog = emissionLog + directionLog + tripLog;
+  if (!state.LastBest) {
+    return stepLog;
+  }
+  const transition = TransitionScore(
+    state.LastBest.Segment.Order,
+    c.Segment.Order,
+    segmentCount,
+    cfg.Looping
+  );
+  return state.LastBest.TotalLogScore + logScore(transition) + stepLog;
+}
+function applySegmentSwitchHysteresis(state, best, candidates, segmentCount, point, cfg) {
+  if (!state.LastBest || !best) {
+    return best;
+  }
+  const hyst = cfg.SegmentSwitchHysteresisLog;
+  if (hyst <= 0) {
+    return best;
+  }
+  const prevOrder = state.LastBest.Segment.Order;
+  if (best.Segment.Order === prevOrder) {
+    return best;
+  }
+  let prevBest = null;
+  for (const c of candidates) {
+    if (c.Segment.Order !== prevOrder) continue;
+    if (rejectBackwardCandidate(state, c, segmentCount, point, cfg)) {
+      continue;
+    }
+    const copy = { ...c };
+    copy.TotalLogScore = viterbiTotalScore(
+      state,
+      copy,
+      segmentCount,
+      cfg
+    );
+    if (!prevBest || copy.TotalLogScore > prevBest.TotalLogScore) {
+      prevBest = copy;
+    }
+  }
+  if (!prevBest) {
+    return best;
+  }
+  const ambiguousDistM = 12;
+  if (best.DistanceMeter > ambiguousDistM || prevBest.DistanceMeter > ambiguousDistM) {
+    return best;
+  }
+  if (Math.abs(best.DistanceMeter - prevBest.DistanceMeter) > 5) {
+    return best;
+  }
+  if (best.TotalLogScore - prevBest.TotalLogScore < hyst) {
+    return prevBest;
+  }
+  return best;
+}
+function pickNearestForwardCandidate(candidates, state, segmentCount, looping) {
+  if (candidates.length === 0) {
+    return null;
+  }
+  let refOrder = 0;
+  if (state?.LastBest) {
+    refOrder = state.LastBest.Segment.Order;
+  }
+  let maxOrder = refOrder + 1;
+  if (refOrder <= 0) {
+    maxOrder = 0;
+  }
+  let best = null;
+  for (const c of candidates) {
+    if (refOrder > 0) {
+      if (c.Segment.Order < refOrder && !isLoopWrapTransition(
+        refOrder,
+        c.Segment.Order,
+        segmentCount,
+        looping
+      )) {
+        continue;
+      }
+      if (maxOrder > 0 && c.Segment.Order > maxOrder && !isLoopWrapTransition(
+        refOrder,
+        c.Segment.Order,
+        segmentCount,
+        looping
+      )) {
+        continue;
+      }
+    }
+    if (!best || c.DistanceMeter < best.DistanceMeter) {
+      best = { ...c };
+    }
+  }
+  return best;
+}
+function runViterbiStep(state, candidates, segmentCount, point, cfg) {
+  if (candidates.length === 0) {
+    return null;
+  }
+  let best = null;
+  const looping = cfg.Looping;
+  for (const c of candidates) {
+    if (rejectBackwardCandidate(state, c, segmentCount, point, cfg)) {
+      continue;
+    }
+    if (rejectSegmentSwitch(state, c, segmentCount, point, cfg) && (cfg.RequireNextStopBeforeSegmentSwitch || cfg.RequireStopRadiusForSegmentSwitch)) {
+      continue;
+    }
+    const emissionLog = logScore(c.EmissionScore);
+    const directionLog = logScore(c.DirectionScore);
+    const tripLog = logScore(c.TripDirectionScore);
+    const stepLog = emissionLog + directionLog + tripLog;
+    if (!state.LastBest) {
+      const total2 = stepLog;
+      const candidate2 = { ...c, TotalLogScore: total2 };
+      if (!best || candidate2.TotalLogScore > best.TotalLogScore) {
+        best = candidate2;
+      }
+      continue;
+    }
+    const transition = TransitionScore(
+      state.LastBest.Segment.Order,
+      c.Segment.Order,
+      segmentCount,
+      looping
+    );
+    const total = state.LastBest.TotalLogScore + logScore(transition) + stepLog;
+    const candidate = { ...c, TotalLogScore: total, Prev: state.LastBest };
+    if (!best || candidate.TotalLogScore > best.TotalLogScore) {
+      best = candidate;
+    }
+  }
+  best = applySegmentSwitchHysteresis(
+    state,
+    best,
+    candidates,
+    segmentCount,
+    point,
+    cfg
+  );
+  if (!best && state.LastBest && cfg.PreventBackwardTransition) {
+    for (const c of candidates) {
+      if (c.Segment.Order === state.LastBest.Segment.Order) {
+        return { ...c };
+      }
+    }
+  }
+  if (!best && state.LastBest && cfg.PreventBackwardTransition) {
+    return pickNearestForwardCandidate(
+      candidates,
+      state,
+      segmentCount,
+      looping
+    );
+  }
+  return best;
+}
+
+// src/live-bus-config.ts
+var RecommendedMaxSnapDistanceMeter = 28;
+var RecommendedMaxBearingDiffDegree = 40;
+var RecommendedMinMovementMeter = 3;
+var RecommendedMeasureRegressionToleranceMeter = 10;
+var RecommendedClampBackwardMinConfidence = 0.78;
+var RecommendedSegmentSwitchHysteresisLog = 2.5;
+var RecommendedMeasureAdvanceSlackMeter = 8;
+var RecommendedClampDwellSpeedKmh = 10;
+var RecommendedSnappedJumpSlackMeter = 2;
+var RecommendedSegmentSwitchStopRadiusMeter = 20;
+var RecommendedLoopClosureToleranceMeter = 15;
+var RecommendedLoopNextStopPassToleranceMeter = 18;
+var RecommendedSnapDistanceResetMaxMeter = 100;
+var RecommendedSnapDistanceGrowResetTicks = DefaultSnapDistanceGrowResetTicks;
+var RecommendedSnapDistanceGrowMinDeltaM = DefaultSnapDistanceGrowMinDeltaM;
+var RecommendedSnapDistanceResetMinMeter = DefaultSnapDistanceResetMinMeter;
+function IsLoopRoute(stops) {
+  return detectLoopFromStops(stops, true, RecommendedLoopClosureToleranceMeter);
+}
+function LiveBusSnapConfig(stops) {
+  const opts = [
+    WithMeasureRegressionTolerance(
+      RecommendedMeasureRegressionToleranceMeter
+    ),
+    WithClampBackwardMinConfidence(RecommendedClampBackwardMinConfidence),
+    WithSegmentSwitchHysteresisLog(RecommendedSegmentSwitchHysteresisLog),
+    WithMeasureAdvanceSlack(RecommendedMeasureAdvanceSlackMeter),
+    WithClampDwellSpeedKmh(RecommendedClampDwellSpeedKmh),
+    WithSnappedJumpSlack(RecommendedSnappedJumpSlackMeter),
+    WithRequireStopRadiusForSegmentSwitch(true),
+    WithSegmentSwitchStopRadiusMeter(RecommendedSegmentSwitchStopRadiusMeter),
+    WithLoopClosureTolerance(RecommendedLoopClosureToleranceMeter),
+    WithSnapDistanceResetMaxMeter(RecommendedSnapDistanceResetMaxMeter)
+  ];
+  if (IsLoopRoute(stops)) {
+    opts.push(
+      WithSnapDistanceResetOnGrow(false),
+      WithNextStopPassToleranceMeter(
+        RecommendedLoopNextStopPassToleranceMeter
+      )
+    );
+  } else {
+    opts.push(
+      WithSnapDistanceResetOnGrow(true),
+      WithSnapDistanceGrowResetTicks(RecommendedSnapDistanceGrowResetTicks),
+      WithSnapDistanceGrowMinDeltaM(RecommendedSnapDistanceGrowMinDeltaM),
+      WithSnapDistanceResetMinMeter(RecommendedSnapDistanceResetMinMeter)
+    );
+  }
+  const cfg = RouteSnapConfig(stops, ...opts);
+  cfg.MaxSnapDistanceMeter = RecommendedMaxSnapDistanceMeter;
+  cfg.MaxBearingDiffDegree = RecommendedMaxBearingDiffDegree;
+  cfg.MinMovementMeter = RecommendedMinMovementMeter;
+  return cfg;
+}
+
+// src/off-route-policy.ts
+var DefaultOffRouteSoftDistFraction = 0.54;
+var DefaultOffRouteMinConfidence = 0.2;
+var DefaultOffRouteSoftConfidence = 0.5;
+function DefaultOffRoutePolicy() {
+  return {
+    MaxSnapDistanceMeter: 28,
+    OffRouteSoftDistFraction: DefaultOffRouteSoftDistFraction,
+    OffRouteMinConfidence: DefaultOffRouteMinConfidence,
+    OffRouteSoftConfidence: DefaultOffRouteSoftConfidence
+  };
+}
+function normalized(policy) {
+  const defaults = DefaultOffRoutePolicy();
+  return {
+    MaxSnapDistanceMeter: policy.MaxSnapDistanceMeter > 0 ? policy.MaxSnapDistanceMeter : defaults.MaxSnapDistanceMeter,
+    OffRouteSoftDistFraction: policy.OffRouteSoftDistFraction > 0 ? policy.OffRouteSoftDistFraction : DefaultOffRouteSoftDistFraction,
+    OffRouteMinConfidence: policy.OffRouteMinConfidence > 0 ? policy.OffRouteMinConfidence : DefaultOffRouteMinConfidence,
+    OffRouteSoftConfidence: policy.OffRouteSoftConfidence > 0 ? policy.OffRouteSoftConfidence : DefaultOffRouteSoftConfidence
+  };
+}
+function offRouteSoftDistM(policy) {
+  const p = normalized(policy);
+  return p.MaxSnapDistanceMeter * p.OffRouteSoftDistFraction;
+}
+function SnapDegraded(result) {
+  if (!result) {
+    return true;
+  }
+  if (!result.SegmentID || result.SegmentOrder <= 0) {
+    return true;
+  }
+  if (result.RejectedReason) {
+    return true;
+  }
+  return !!(result.HeldSegment && result.IsOffRoute);
+}
+function MapOffRoute(result, snapDegraded, policy) {
+  const p = normalized(policy);
+  if (!result || snapDegraded) {
+    return true;
+  }
+  let isOffRoute = result.IsOffRoute;
+  if (result.HeldSegment) {
+    isOffRoute = false;
+  }
+  if (isOffRoute || result.HeldSegment) {
+    return isOffRoute;
+  }
+  if (result.Confidence < p.OffRouteMinConfidence) {
+    return true;
+  }
+  const soft = offRouteSoftDistM(p);
+  if (result.DistanceMeter > soft && result.Confidence < p.OffRouteSoftConfidence) {
+    return true;
+  }
+  return false;
+}
+function EtaSnapUnreliable(result, snapDegraded, policy) {
+  const p = normalized(policy);
+  if (!result || snapDegraded) {
+    return true;
+  }
+  if (result.IsOffRoute) {
+    return true;
+  }
+  if (result.DistanceMeter > p.MaxSnapDistanceMeter) {
+    return true;
+  }
+  const soft = offRouteSoftDistM(p);
+  if (result.DistanceMeter > soft && result.Confidence < p.OffRouteSoftConfidence) {
+    return true;
+  }
+  if (result.Confidence < p.OffRouteMinConfidence) {
+    return true;
+  }
+  return false;
+}
+function EtaSnapReliableForPublish(result, snapDegraded, policy) {
+  if (EtaSnapUnreliable(result, snapDegraded, policy)) {
+    return false;
+  }
+  return (result?.SegmentOrder ?? 0) > 0;
+}
+
+// src/snap-helpers.ts
+var backwardMeasureEpsilonM = 0.5;
+function candidateFromProjection(ctx, seg, point, proj) {
+  const absMeasure = seg.FromMeasure + proj.Measure;
+  const lineBearing = BearingAtMeasure(seg.Geometry, proj.Measure);
+  const [busBearing, hasBearing] = resolveBusBearing(
+    point,
+    ctx.state.LastPoint,
+    ctx.config
+  );
+  const weaken = shouldWeakenDirectionValidation(
+    point,
+    ctx.state.LastPoint,
+    ctx.config
+  );
+  const emission = EmissionScore(
+    proj.DistanceMeter,
+    ctx.config.MaxSnapDistanceMeter
+  );
+  const [dirScore] = scoreDirection(
+    busBearing,
+    hasBearing,
+    lineBearing,
+    ctx.config,
+    weaken
+  );
+  const tripScore = TripDirectionScore(
+    seg.Direction,
+    ctx.config.TripDirection
+  );
+  return {
+    Segment: seg,
+    Measure: absMeasure,
+    SnappedPoint: proj.Point,
+    DistanceMeter: proj.DistanceMeter,
+    LineBearing: lineBearing,
+    EmissionScore: emission,
+    DirectionScore: dirScore,
+    TripDirectionScore: tripScore
+  };
+}
+function candidateOnSegment(ctx, seg, point) {
+  const proj = projectOntoSegment(
+    seg,
+    point,
+    ctx.state.LastPoint,
+    ctx.state,
+    ctx.config
+  );
+  return candidateFromProjection(ctx, seg, point, proj);
+}
+function resultFromCandidate(ctx, best, point) {
+  const [busBearing, hasBearing] = resolveBusBearing(
+    point,
+    ctx.state.LastPoint,
+    ctx.config
+  );
+  const weaken = shouldWeakenDirectionValidation(
+    point,
+    ctx.state.LastPoint,
+    ctx.config
+  );
+  const [, directionDiff] = scoreDirection(
+    busBearing,
+    hasBearing,
+    best.LineBearing,
+    ctx.config,
+    weaken
+  );
+  let resolvedBusBearing = busBearing;
+  if (!hasBearing && ctx.state.LastBest) {
+    resolvedBusBearing = ctx.state.LastBest.LineBearing;
+  }
+  return {
+    OriginalPoint: point.Point,
+    SnappedPoint: best.SnappedPoint,
+    SegmentID: best.Segment.ID,
+    SegmentOrder: best.Segment.Order,
+    Direction: best.Segment.Direction,
+    NearestStopID: nearestStopID(ctx.stops, best.SnappedPoint),
+    DistanceMeter: best.DistanceMeter,
+    Progress: segmentProgress(best.Segment, best.Measure),
+    BusBearing: resolvedBusBearing,
+    LineBearing: best.LineBearing,
+    DirectionDiff: directionDiff,
+    Confidence: clampConfidence(confidenceFromScores(best)),
+    IsOffRoute: best.DistanceMeter > ctx.config.MaxSnapDistanceMeter
+  };
+}
+function holdReferenceCandidate(ctx) {
+  if (ctx.state.LastBest?.Segment.Order) {
+    return ctx.state.LastBest;
+  }
+  if (ctx.state.LastGood?.Segment.Order) {
+    return ctx.state.LastGood;
+  }
+  return null;
+}
+function clampToPreviousSegmentWithMaxDist(ctx, point, maxSnapDist) {
+  const ref = holdReferenceCandidate(ctx);
+  if (!ref) {
+    return [null, null];
+  }
+  const seg = ref.Segment;
+  const prevRel = ref.Measure - seg.FromMeasure;
+  const lastAbs = ref.Measure;
+  const lastSnapped = ref.SnappedPoint;
+  let tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteMeasureRegressionToleranceMeter;
+  }
+  let advanceSlack = ctx.config.MeasureAdvanceSlackMeter;
+  if (advanceSlack <= 0) {
+    advanceSlack = DefaultRouteMeasureAdvanceSlackMeter;
+  }
+  let movement = 0;
+  if (ctx.state.LastPoint) {
+    movement = DistanceMeter(ctx.state.LastPoint.Point, point.Point);
+  }
+  let maxAdvance = movement * 1.5 + advanceSlack;
+  if (movement > 0 && movement < 1) {
+    maxAdvance = 1.5 + advanceSlack;
+  }
+  let proj = ProjectPointOnLineContinued(
+    seg.Geometry,
+    point.Point,
+    prevRel,
+    ctx.state.LastPoint,
+    lastSnapped,
+    ctx.config
+  );
+  const minRel = prevRel - tol;
+  const maxRel = prevRel + maxAdvance;
+  const [forward, ok] = ForwardProjectionOnSegment(
+    seg.Geometry,
+    point.Point,
+    minRel,
+    maxRel,
+    maxSnapDist
+  );
+  if (ok) {
+    const absForward = seg.FromMeasure + forward.Measure;
+    const absProj = seg.FromMeasure + proj.Measure;
+    if (absForward >= lastAbs - tol && (absProj < lastAbs - tol || absForward > absProj)) {
+      proj = forward;
+    }
+  }
+  if (seg.FromMeasure + proj.Measure < lastAbs - tol) {
+    const after = FindNearestProjectionAfterMeasure(
+      seg.Geometry,
+      point.Point,
+      prevRel
+    );
+    if (after.DistanceMeter <= maxSnapDist && seg.FromMeasure + after.Measure >= lastAbs - tol) {
+      proj = after;
+    }
+  }
+  if (seg.FromMeasure + proj.Measure < lastAbs - tol) {
+    proj = {
+      Point: lastSnapped,
+      Measure: prevRel,
+      LineIndex: 0,
+      DistanceMeter: DistanceMeter(point.Point, lastSnapped)
+    };
+  }
+  const candidate = candidateFromProjection(ctx, seg, point, proj);
+  const result = resultFromCandidate(ctx, candidate, point);
+  return [result, candidate];
+}
+function holdLastSegmentMaxDistM(ctx) {
+  if (ctx.config.HoldLastSegmentMaxDistM > 0) {
+    return ctx.config.HoldLastSegmentMaxDistM;
+  }
+  if (ctx.config.MaxSnapDistanceMeter > 0) {
+    return Math.max(
+      DefaultRouteHoldLastSegmentMaxDistM,
+      ctx.config.MaxSnapDistanceMeter * 2
+    );
+  }
+  return DefaultRouteHoldLastSegmentMaxDistM;
+}
+function holdLastSegmentMaxAgeMs(ctx) {
+  if (ctx.config.HoldLastSegmentMaxAgeMs > 0) {
+    return ctx.config.HoldLastSegmentMaxAgeMs;
+  }
+  return DefaultRouteHoldLastSegmentMaxAgeMs;
+}
+function holdLastSegmentMinConfidence(ctx) {
+  if (ctx.config.HoldLastSegmentMinConfidence > 0) {
+    return ctx.config.HoldLastSegmentMinConfidence;
+  }
+  return DefaultRouteHoldLastSegmentMinConfidence;
+}
+function holdLastSegmentAgeOK(ctx, point) {
+  const maxAge = holdLastSegmentMaxAgeMs(ctx);
+  if (ctx.state.LastTimestamp <= 0) {
+    return true;
+  }
+  let now = point.Timestamp ?? 0;
+  if (now <= 0) {
+    now = Date.now();
+  }
+  const delta = now - ctx.state.LastTimestamp;
+  if (delta < 0) {
+    return true;
+  }
+  return delta <= maxAge;
+}
+function applyHeldSegmentResult(ctx, result, reason) {
+  const minConf = holdLastSegmentMinConfidence(ctx);
+  let conf = result.Confidence * 0.5;
+  if (conf < minConf) {
+    conf = minConf;
+  }
+  return {
+    ...result,
+    Confidence: clampConfidence(conf),
+    HeldSegment: true,
+    HeldReason: reason,
+    IsOffRoute: false,
+    RejectedReason: ""
+  };
+}
+function holdLastSegmentOnMiss(ctx, point) {
+  if (!ctx.config.HoldLastSegmentOnMiss || !holdReferenceCandidate(ctx)) {
+    return [null, null];
+  }
+  if (!holdLastSegmentAgeOK(ctx, point)) {
+    return [null, null];
+  }
+  let projMax = holdLastSegmentMaxDistM(ctx);
+  if (projMax < 500) {
+    projMax = 500;
+  }
+  const [result, candidate] = clampToPreviousSegmentWithMaxDist(
+    ctx,
+    point,
+    projMax
+  );
+  if (!result || !candidate) {
+    return [null, null];
+  }
+  if (!result.SegmentID || result.SegmentOrder <= 0) {
+    return [null, null];
+  }
+  return [applyHeldSegmentResult(ctx, result, "no_candidates"), candidate];
+}
+function tryHoldLastSegment(ctx, point, reason) {
+  if (!ctx.config.HoldLastSegmentOnMiss) {
+    return [null, null];
+  }
+  const [result, best] = holdLastSegmentOnMiss(ctx, point);
+  if (result) {
+    if (reason && reason !== "no_candidates") {
+      result.HeldReason = reason;
+    }
+    return [result, best];
+  }
+  return [null, null];
+}
+function shouldClampBackward(ctx, result) {
+  if (!ctx.config.PreventBackwardTransition || !ctx.state.LastBest) {
+    return false;
+  }
+  if (isLoopWrapTransition(
+    ctx.state.LastBest.Segment.Order,
+    result.SegmentOrder,
+    ctx.segments.length,
+    ctx.config.Looping
+  )) {
+    return false;
+  }
+  return result.SegmentOrder < ctx.state.LastBest.Segment.Order;
+}
+function shouldClampMeasureRegression(ctx, result) {
+  if (!ctx.state.LastBest) {
+    return false;
+  }
+  const tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    return false;
+  }
+  if (isLoopWrapTransition(
+    ctx.state.LastBest.Segment.Order,
+    result.SegmentOrder,
+    ctx.segments.length,
+    ctx.config.Looping
+  )) {
+    return false;
+  }
+  const resMeasure = routeMeasure(ctx, result.SegmentOrder, result.Progress);
+  return resMeasure < ctx.state.LastBest.Measure - tol;
+}
+function shouldClampLateral(ctx, result, point) {
+  if (!ctx.state.LastBest || !ctx.state.LastPoint) {
+    return false;
+  }
+  if (ctx.config.ClampBackwardMinConfidence <= 0) {
+    return false;
+  }
+  const jump = DistanceMeter(
+    ctx.state.LastBest.SnappedPoint,
+    result.SnappedPoint
+  );
+  let movement = DistanceMeter(ctx.state.LastPoint.Point, point.Point);
+  if (movement < 1) {
+    movement = 1;
+  }
+  let jumpSlack = ctx.config.SnappedJumpSlackMeter;
+  if (jumpSlack <= 0) {
+    jumpSlack = DefaultRouteSnappedJumpSlackMeter;
+  }
+  let dwellSpeed = ctx.config.ClampDwellSpeedKmh;
+  if (dwellSpeed <= 0) {
+    dwellSpeed = DefaultRouteClampDwellSpeedKmh;
+  }
+  const isDwell = (point.Speed ?? 0) < 3 || ctx.config.UseSpeed && (point.Speed ?? 0) <= dwellSpeed || movement < ctx.config.MinMovementMeter;
+  let confLimit = 0.7;
+  if (isDwell) {
+    confLimit = 0.85;
+  }
+  if (result.Confidence >= confLimit) {
+    return false;
+  }
+  if (isDwell && jump > jumpSlack) {
+    return true;
+  }
+  return jump > movement * 0.75 + jumpSlack && jump > 4;
+}
+function stabilizeSameSegmentCandidate(ctx, best, point) {
+  if (!ctx.state.LastBest || !best || best.Segment.Order !== ctx.state.LastBest.Segment.Order) {
+    return best;
+  }
+  let jumpSlack = ctx.config.SnappedJumpSlackMeter;
+  if (jumpSlack <= 0) {
+    jumpSlack = DefaultRouteSnappedJumpSlackMeter;
+  }
+  let movement = 1;
+  if (ctx.state.LastPoint) {
+    movement = DistanceMeter(ctx.state.LastPoint.Point, point.Point);
+    if (movement < 1) {
+      movement = 1;
+    }
+  }
+  const jump = DistanceMeter(
+    ctx.state.LastBest.SnappedPoint,
+    best.SnappedPoint
+  );
+  const maxJump = movement * 1.25 + jumpSlack;
+  if (jump <= maxJump || jump <= 5) {
+    return best;
+  }
+  const continued = candidateOnSegment(
+    ctx,
+    ctx.state.LastBest.Segment,
+    point
+  );
+  let tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteMeasureRegressionToleranceMeter;
+  }
+  if (continued.Measure >= ctx.state.LastBest.Measure - tol) {
+    return continued;
+  }
+  return best;
+}
+function softMaxSnapDist(ctx) {
+  if (ctx.config.MaxSnapDistanceMeter <= 0) {
+    return 18;
+  }
+  const soft = ctx.config.MaxSnapDistanceMeter * 0.65;
+  return soft < 12 ? 12 : soft;
+}
+function preferNearbyOnActiveSegment(ctx, best, point) {
+  if (!ctx.state.LastBest || !best) {
+    return best;
+  }
+  if (forwardDepartLatchActive(ctx.state, ctx.state.LastBest.Segment.Order)) {
+    return best;
+  }
+  const soft = softMaxSnapDist(ctx);
+  if (best.DistanceMeter <= soft) {
+    return best;
+  }
+  const lastSeg = ctx.state.LastBest.Segment;
+  const onLast = candidateOnSegment(ctx, lastSeg, point);
+  if (onLast.DistanceMeter > ctx.config.MaxSnapDistanceMeter) {
+    return best;
+  }
+  let tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteMeasureRegressionToleranceMeter;
+  }
+  const measureOK = onLast.Measure >= ctx.state.LastBest.Measure - tol;
+  if (best.Segment.Order === lastSeg.Order && onLast.DistanceMeter < best.DistanceMeter) {
+    return onLast;
+  }
+  if (onLast.DistanceMeter + 2 < best.DistanceMeter && measureOK) {
+    return onLast;
+  }
+  if (best.Segment.Order !== lastSeg.Order && best.DistanceMeter > soft && onLast.DistanceMeter <= soft && measureOK) {
+    return onLast;
+  }
+  return best;
+}
+function segmentAtRouteMeasure(ctx, m) {
+  for (const seg of ctx.segments) {
+    if (m >= seg.FromMeasure && m <= seg.ToMeasure) {
+      return seg;
+    }
+  }
+  if (ctx.segments.length === 0) {
+    return null;
+  }
+  const last = ctx.segments[ctx.segments.length - 1];
+  if (m > last.ToMeasure) {
+    return last;
+  }
+  const first = ctx.segments[0];
+  if (m < first.FromMeasure) {
+    return first;
+  }
+  return null;
+}
+function candidateAtRouteMeasure(ctx, seg, absMeasure, point) {
+  let rel = absMeasure - seg.FromMeasure;
+  if (rel < 0) rel = 0;
+  const segLen = seg.ToMeasure - seg.FromMeasure;
+  if (segLen > 0 && rel > segLen) {
+    rel = segLen;
+  }
+  const [pt] = PointAtMeasure(seg.Geometry, rel);
+  const proj = {
+    Point: pt,
+    Measure: rel,
+    DistanceMeter: DistanceMeter(point.Point, pt)};
+  const candidate = candidateFromProjection(ctx, seg, point, proj);
+  candidate.Measure = seg.FromMeasure + rel;
+  const result = resultFromCandidate(ctx, candidate, point);
+  return [result, candidate];
+}
+function routeMeasure(ctx, order, progress) {
+  for (const seg of ctx.segments) {
+    if (seg.Order === order) {
+      return seg.FromMeasure + progress * (seg.ToMeasure - seg.FromMeasure);
+    }
+  }
+  return 0;
+}
+function gpsMovesForwardAlongRoute(ctx, point, ref) {
+  if (!ctx.state.LastPoint || !ref) {
+    return false;
+  }
+  const movement = DistanceMeter(ctx.state.LastPoint.Point, point.Point);
+  let minMov = ctx.config.MinMovementMeter;
+  if (minMov <= 0) {
+    minMov = 3;
+  }
+  if (movement < minMov) {
+    return false;
+  }
+  const moveBearing = BearingBetween(
+    ctx.state.LastPoint.Point,
+    point.Point
+  );
+  return bearingDiffDeg(moveBearing, ref.LineBearing) <= 90;
+}
+function applyStabilizedResult(ctx, result, reason) {
+  const minConf = holdLastSegmentMinConfidence(ctx);
+  let conf = result.Confidence * 0.6;
+  if (conf < minConf) {
+    conf = minConf;
+  }
+  return {
+    ...result,
+    Confidence: clampConfidence(conf),
+    HeldSegment: true,
+    HeldReason: reason,
+    IsOffRoute: false,
+    RejectedReason: ""
+  };
+}
+function freezeAtRefCandidate(ctx, point, ref, reason) {
+  if (!ref) {
+    return [null, null];
+  }
+  const seg = ref.Segment;
+  const prevRel = ref.Measure - seg.FromMeasure;
+  const proj = {
+    Point: ref.SnappedPoint,
+    Measure: prevRel,
+    DistanceMeter: DistanceMeter(point.Point, ref.SnappedPoint)};
+  const candidate = candidateFromProjection(ctx, seg, point, proj);
+  candidate.Measure = ref.Measure;
+  let result = resultFromCandidate(ctx, candidate, point);
+  result = applyStabilizedResult(ctx, result, reason);
+  return [result, candidate];
+}
+function plausibleRawGPSMovementM(ctx, point) {
+  let slack = ctx.config.MeasureAdvanceSlackMeter;
+  if (slack <= 0) {
+    slack = DefaultRouteMeasureAdvanceSlackMeter;
+  }
+  let deltaSec = 1;
+  if ((point.Timestamp ?? 0) > 0 && ctx.state.LastTimestamp > 0) {
+    deltaSec = (point.Timestamp - ctx.state.LastTimestamp) / 1e3;
+  }
+  if (deltaSec < 0.3) deltaSec = 0.3;
+  if (deltaSec > 30) deltaSec = 30;
+  let speedKmh = point.Speed ?? 0;
+  if (speedKmh <= 0 && ctx.state.LastPoint) {
+    speedKmh = ctx.state.LastPoint.Speed ?? 0;
+  }
+  if (speedKmh <= 0) {
+    speedKmh = 40;
+  }
+  return speedKmh / 3.6 * deltaSec + slack;
+}
+function isWildGPSJump(ctx, point) {
+  if (!ctx.state.LastPoint) {
+    return false;
+  }
+  const raw = DistanceMeter(ctx.state.LastPoint.Point, point.Point);
+  let minM = ctx.config.WildGPSJumpMinMeter;
+  if (minM <= 0) {
+    minM = DefaultRouteWildGPSJumpMinMeter;
+  }
+  if (raw < minM) {
+    return false;
+  }
+  let mult = ctx.config.WildGPSJumpMultiplier;
+  if (mult <= 0) {
+    mult = DefaultRouteWildGPSJumpMultiplier;
+  }
+  return raw > plausibleRawGPSMovementM(ctx, point) * mult;
+}
+function creepForwardOnSegment(ctx, point, ref) {
+  if (!ref) {
+    return [null, null];
+  }
+  let creep = plausibleRawGPSMovementM(ctx, point);
+  if (ctx.config.MaxForwardSnapMeter > 0 && creep > ctx.config.MaxForwardSnapMeter) {
+    creep = ctx.config.MaxForwardSnapMeter;
+  }
+  let advSlack = ctx.config.MeasureAdvanceSlackMeter;
+  if (advSlack <= 0) {
+    advSlack = DefaultRouteMeasureAdvanceSlackMeter;
+  }
+  if (ctx.state.LastPoint) {
+    const movement = DistanceMeter(
+      ctx.state.LastPoint.Point,
+      point.Point
+    );
+    const cap = movement * 1.5 + advSlack;
+    if (creep > cap) {
+      creep = cap;
+    }
+  }
+  if (creep < 0.5) {
+    return [null, null];
+  }
+  let targetM = ref.Measure + creep;
+  let seg = segmentAtRouteMeasure(ctx, targetM);
+  if (!seg || seg.Order < ref.Segment.Order) {
+    seg = ref.Segment;
+    targetM = Math.min(ref.Measure + creep, ref.Segment.ToMeasure);
+  }
+  return candidateAtRouteMeasure(ctx, seg, targetM, point);
+}
+function advanceAlongRoute(ctx, point, reason) {
+  const ref = ctx.state.LastBest;
+  if (!ref) {
+    return [null, null];
+  }
+  let maxDist = holdLastSegmentMaxDistM(ctx);
+  if (maxDist < 500) {
+    maxDist = 500;
+  }
+  const [result, candidate] = clampToPreviousSegmentWithMaxDist(
+    ctx,
+    point,
+    maxDist
+  );
+  if (candidate && candidate.Measure > ref.Measure + backwardMeasureEpsilonM) {
+    if (result) {
+      return [applyStabilizedResult(ctx, result, reason), candidate];
+    }
+  }
+  if (gpsMovesForwardAlongRoute(ctx, point, ref)) {
+    const [crept, c] = creepForwardOnSegment(ctx, point, ref);
+    if (crept) {
+      return [applyStabilizedResult(ctx, crept, reason), c];
+    }
+  }
+  return freezeAtRefCandidate(ctx, point, ref, reason);
+}
+function noBackwardSnapEnabled(ctx) {
+  if (ctx.config.NoBackwardSnap) {
+    return true;
+  }
+  return ctx.config.PreventBackwardTransition;
+}
+function enforceNoBackwardSnap(ctx, best, point) {
+  if (!noBackwardSnapEnabled(ctx) || !ctx.state.LastBest || !best) {
+    return [null, null];
+  }
+  const ref = ctx.state.LastBest;
+  const loopWrap = isLoopWrapTransition(
+    ref.Segment.Order,
+    best.Segment.Order,
+    ctx.segments.length,
+    ctx.config.Looping
+  );
+  if (loopWrap) {
+    return [null, null];
+  }
+  let backward = false;
+  if (best.Segment.Order < ref.Segment.Order) {
+    backward = true;
+  }
+  if (best.Measure < ref.Measure - backwardMeasureEpsilonM) {
+    backward = true;
+  }
+  if (!backward) {
+    return [null, null];
+  }
+  if (best.Measure < ref.Measure - backwardMeasureEpsilonM && !gpsMovesForwardAlongRoute(ctx, point, ref)) {
+    return freezeAtRefCandidate(ctx, point, ref, "no_backward");
+  }
+  return advanceAlongRoute(ctx, point, "no_backward");
+}
+function snapDistanceResetEnabled(cfg) {
+  return cfg.SnapDistanceResetOnGrow;
+}
+function snapDistanceGrowResetTicks(cfg) {
+  return cfg.SnapDistanceGrowResetTicks > 0 ? cfg.SnapDistanceGrowResetTicks : DefaultSnapDistanceGrowResetTicks;
+}
+function snapDistanceGrowMinDeltaM(cfg) {
+  return cfg.SnapDistanceGrowMinDeltaM > 0 ? cfg.SnapDistanceGrowMinDeltaM : DefaultSnapDistanceGrowMinDeltaM;
+}
+function snapDistanceResetMinMeter(cfg) {
+  if (cfg.SnapDistanceResetMinMeter > 0) {
+    return cfg.SnapDistanceResetMinMeter;
+  }
+  const maxSnap = cfg.MaxSnapDistanceMeter;
+  if (maxSnap > 0) {
+    return maxSnap + 4;
+  }
+  return DefaultSnapDistanceResetMinMeter;
+}
+function snapDistanceResetMaxMeter(cfg) {
+  if (cfg.SnapDistanceResetMaxMeter === 0) {
+    return 0;
+  }
+  if (cfg.SnapDistanceResetMaxMeter > 0) {
+    return cfg.SnapDistanceResetMaxMeter;
+  }
+  return DefaultSnapDistanceResetMaxMeter;
+}
+function lateralDistFromLastSnapM(ctx, point) {
+  if (!ctx.state.LastBest) {
+    return 0;
+  }
+  const proj = projectOntoSegment(
+    ctx.state.LastBest.Segment,
+    point,
+    ctx.state.LastPoint,
+    ctx.state,
+    ctx.config
+  );
+  return proj.DistanceMeter;
+}
+function resetSnapTrackingState(ctx) {
+  const activeDir = ctx.state.ActiveDirection;
+  ctx.state.LastCandidates = [];
+  ctx.state.LastBest = null;
+  ctx.state.LastGood = null;
+  ctx.state.LastPoint = null;
+  ctx.state.LastTimestamp = 0;
+  ctx.state.BranchLock = null;
+  ctx.state.BranchNormalTicks = 0;
+  ctx.state.RecentBranchTicks = [];
+  ctx.state.LastOutputSnapDistanceM = 0;
+  ctx.state.GrowingSnapDistTicks = 0;
+  ctx.state.SegmentDepart = {
+    GateSegmentOrder: 0,
+    WasInsideRadius: false,
+    HasDeparted: false
+  };
+  ctx.state.ActiveDirection = activeDir;
+}
+function maybeResetSnapDistance(ctx, point) {
+  if (!ctx.state.LastBest) {
+    return false;
+  }
+  const ref = ctx.state.LastBest;
+  const lateralDist = lateralDistFromLastSnapM(ctx, point);
+  const maxReset = snapDistanceResetMaxMeter(ctx.config);
+  if (maxReset > 0 && lateralDist >= maxReset) {
+    resetSnapTrackingState(ctx);
+    return true;
+  }
+  if (!snapDistanceResetEnabled(ctx.config)) {
+    return false;
+  }
+  const dist = DistanceMeter(point.Point, ref.SnappedPoint);
+  const minDist = snapDistanceResetMinMeter(ctx.config);
+  if (dist < minDist) {
+    ctx.state.GrowingSnapDistTicks = 0;
+    return false;
+  }
+  let maxSnap = ctx.config.MaxSnapDistanceMeter;
+  if (maxSnap <= 0) {
+    maxSnap = 28;
+  }
+  if (ctx.state.LastPoint && dist < maxSnap * 2) {
+    const moveBearing = BearingBetween(
+      ctx.state.LastPoint.Point,
+      point.Point
+    );
+    if (bearingDiffDeg(moveBearing, ref.LineBearing) > 90) {
+      ctx.state.GrowingSnapDistTicks = 0;
+      return false;
+    }
+  }
+  const prevDist = ctx.state.LastOutputSnapDistanceM;
+  const growDelta = snapDistanceGrowMinDeltaM(ctx.config);
+  if (prevDist > 0 && dist > prevDist + growDelta) {
+    ctx.state.GrowingSnapDistTicks++;
+  } else if (dist <= prevDist) {
+    ctx.state.GrowingSnapDistTicks = 0;
+  }
+  if (ctx.state.GrowingSnapDistTicks < snapDistanceGrowResetTicks(ctx.config)) {
+    return false;
+  }
+  resetSnapTrackingState(ctx);
+  return true;
+}
+function markDistanceReset(result, distReset) {
+  if (distReset && result && !result.HeldReason) {
+    return { ...result, HeldReason: "snap_distance_reset" };
+  }
+  return result;
+}
+function commitSnapState(ctx, candidates, best, point, result) {
+  ctx.state.LastCandidates = candidates;
+  ctx.state.LastBest = best;
+  if (best && best.Segment.Order > 0) {
+    ctx.state.LastGood = { ...best };
+  }
+  ctx.state.LastPoint = point;
+  let ts = point.Timestamp ?? 0;
+  if (ts <= 0) {
+    ts = Date.now();
+  }
+  ctx.state.LastTimestamp = ts;
+  if (result) {
+    ctx.state.LastOutputSnapDistanceM = result.DistanceMeter;
+  }
+}
+function finishSnap(ctx, candidates, best, result, point) {
+  if (!best) {
+    return result;
+  }
+  let out = result ?? resultFromCandidate(ctx, best, point);
+  const [adjusted, fBest] = enforceNoBackwardSnap(ctx, best, point);
+  if (adjusted) {
+    best = fBest;
+    out = adjusted;
+  }
+  commitSnapState(ctx, candidates, best, point, out);
+  return out;
+}
+function isBackwardSegmentTransition(ctx, best) {
+  if (!best || !ctx.state.LastBest || !ctx.config.PreventBackwardTransition) {
+    return false;
+  }
+  const ref = ctx.state.LastBest;
+  if (best.Segment.Order >= ref.Segment.Order) {
+    return false;
+  }
+  return !isLoopWrapTransition(
+    ref.Segment.Order,
+    best.Segment.Order,
+    ctx.segments.length,
+    ctx.config.Looping
+  );
+}
+function enforceForwardSegmentOrder(ctx, best, point) {
+  if (!isBackwardSegmentTransition(ctx, best)) {
+    return best;
+  }
+  return candidateOnSegment(ctx, ctx.state.LastBest.Segment, point);
+}
+function capForwardSnapAdvance(ctx, best, point) {
+  const maxFwd = ctx.config.MaxForwardSnapMeter;
+  if (maxFwd <= 0 || !ctx.state.LastBest || !best) {
+    return [null, null];
+  }
+  const ref = ctx.state.LastBest;
+  const loopWrap = isLoopWrapTransition(
+    ref.Segment.Order,
+    best.Segment.Order,
+    ctx.segments.length,
+    ctx.config.Looping
+  );
+  if (loopWrap) {
+    return [null, null];
+  }
+  const lastM = ref.Measure;
+  const newM = best.Measure;
+  if (newM <= lastM + maxFwd) {
+    return [null, null];
+  }
+  const targetM = lastM + maxFwd;
+  const seg = segmentAtRouteMeasure(ctx, targetM);
+  if (!seg) {
+    return [null, null];
+  }
+  const [result, candidate] = candidateAtRouteMeasure(
+    ctx,
+    seg,
+    targetM,
+    point
+  );
+  if (!result) {
+    return [null, null];
+  }
+  const minConf = holdLastSegmentMinConfidence(ctx);
+  if (result.Confidence < minConf) {
+    result.Confidence = minConf;
+  }
+  result.HeldSegment = true;
+  result.HeldReason = "forward_cap";
+  result.IsOffRoute = false;
+  return [result, candidate];
+}
+function stabilizeWildGPSJump(ctx, best, point) {
+  if (!ctx.config.WildGPSStabilize || !ctx.state.LastBest || !best || !ctx.state.LastPoint) {
+    return [null, null];
+  }
+  if (!isWildGPSJump(ctx, point)) {
+    return [null, null];
+  }
+  const ref = ctx.state.LastBest;
+  let tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteMeasureRegressionToleranceMeter;
+  }
+  const loopWrap = isLoopWrapTransition(
+    ref.Segment.Order,
+    best.Segment.Order,
+    ctx.segments.length,
+    ctx.config.Looping
+  );
+  const lastM = ref.Measure;
+  const newM = best.Measure;
+  if (best.Segment.Order < ref.Segment.Order && !loopWrap) {
+    return advanceAlongRoute(ctx, point, "wild_gps_backward");
+  }
+  if (newM < lastM - tol && !loopWrap) {
+    if (gpsMovesForwardAlongRoute(ctx, point, ref)) {
+      return advanceAlongRoute(ctx, point, "wild_gps_regression");
+    }
+    return freezeAtRefCandidate(ctx, point, ref, "wild_gps_regression");
+  }
+  return [null, null];
+}
+function maxAllowedMeasureAdvanceM(cfg, gpsMovement) {
+  const maxFwd = cfg.MaxForwardSnapMeter;
+  if (maxFwd <= 0) {
+    let advanceSlack = cfg.MeasureAdvanceSlackMeter;
+    if (advanceSlack <= 0) {
+      advanceSlack = DefaultRouteMeasureAdvanceSlackMeter;
+    }
+    let mov = gpsMovement;
+    if (mov < 1) mov = 1;
+    return mov * 3 + advanceSlack;
+  }
+  return maxFwd;
+}
+function resnapOnActiveSegmentWhenDrifted(ctx, best, point) {
+  if (!ctx.state.LastBest) {
+    return best;
+  }
+  const ref = ctx.state.LastBest;
+  let maxSnap = ctx.config.MaxSnapDistanceMeter;
+  if (maxSnap <= 0) maxSnap = 28;
+  const dist = DistanceMeter(point.Point, ref.SnappedPoint);
+  const minDrift = Math.max(maxSnap * 1.15, 20);
+  if (dist < minDrift) {
+    return best;
+  }
+  if (isWildGPSJump(ctx, point)) {
+    return best;
+  }
+  let maxDist = holdLastSegmentMaxDistM(ctx);
+  if (maxDist < maxSnap * 2) {
+    maxDist = maxSnap * 2;
+  }
+  const [, candidate] = clampToPreviousSegmentWithMaxDist(
+    ctx,
+    point,
+    maxDist
+  );
+  if (!candidate) {
+    return best;
+  }
+  let tol = ctx.config.MeasureRegressionToleranceMeter;
+  if (tol <= 0) {
+    tol = DefaultRouteMeasureRegressionToleranceMeter;
+  }
+  if (candidate.Measure < ref.Measure - tol) {
+    return best;
+  }
+  let gpsMovement = 0;
+  if (ctx.state.LastPoint) {
+    gpsMovement = DistanceMeter(
+      ctx.state.LastPoint.Point,
+      point.Point
+    );
+  }
+  const maxAdv = maxAllowedMeasureAdvanceM(ctx.config, gpsMovement);
+  if (candidate.Measure > ref.Measure + maxAdv) {
+    return best;
+  }
+  if (best) {
+    const bestRaw = DistanceMeter(point.Point, best.SnappedPoint);
+    const candRaw = DistanceMeter(point.Point, candidate.SnappedPoint);
+    if (candRaw >= bestRaw) {
+      return best;
+    }
+  }
+  return candidate;
+}
+function applySnapContinuityResult(ctx, best, point, result) {
+  if (result?.HeldReason === "forward_cap") {
+    return [null, best];
+  }
+  if (!ctx.config.SnapContinuityFromPrevious || !ctx.state.LastBest || !best || !ctx.state.LastPoint) {
+    return [null, best];
+  }
+  const ref = ctx.state.LastBest;
+  if (best.Segment.Order !== ref.Segment.Order) {
+    return [null, best];
+  }
+  const measureAdv = best.Measure - ref.Measure;
+  const snapJump = DistanceMeter(ref.SnappedPoint, best.SnappedPoint);
+  if (measureAdv > backwardMeasureEpsilonM || snapJump > backwardMeasureEpsilonM) {
+    return [null, best];
+  }
+  let gpsMovement = DistanceMeter(
+    ctx.state.LastPoint.Point,
+    point.Point
+  );
+  let minMov = ctx.config.MinMovementMeter;
+  if (minMov <= 0) minMov = 3;
+  if (gpsMovement < minMov) {
+    return [null, best];
+  }
+  if (!gpsMovesForwardAlongRoute(ctx, point, ref)) {
+    return [null, best];
+  }
+  const [crept, c] = creepForwardOnSegment(ctx, point, ref);
+  if (!crept || !c || c.Measure <= ref.Measure + backwardMeasureEpsilonM) {
+    return [null, best];
+  }
+  const contResult = resultFromCandidate(ctx, c, point);
+  contResult.HeldSegment = true;
+  contResult.HeldReason = "snap_continuity_creep";
+  const minConf = holdLastSegmentMinConfidence(ctx);
+  if (contResult.Confidence < minConf) {
+    contResult.Confidence = minConf;
+  }
+  contResult.IsOffRoute = contResult.DistanceMeter > ctx.config.MaxSnapDistanceMeter;
+  return [contResult, c];
+}
+function ensureForwardCreepWhenStuck(ctx, best, point) {
+  return applySnapContinuityResult(ctx, best, point, null);
+}
+
+// src/snapper.ts
+var Snapper = class _Snapper {
+  line;
+  segments;
+  stops;
+  config;
+  state;
+  constructor(line, stops, cfg) {
+    if (line.length < 2) {
+      throw ErrInvalidLine;
+    }
+    if (stops.length < 2) {
+      throw ErrInsufficientStops;
+    }
+    const sortedStops = sortStopsByOrder(stops);
+    const segments = BuildSegments(line, sortedStops, cfg);
+    if (segments.length === 0) {
+      throw ErrEmptySegments;
+    }
+    let activeDirection = DirectionUnknown;
+    if (cfg.UseTripDirection) {
+      activeDirection = cfg.TripDirection;
+    }
+    this.line = line;
+    this.segments = segments;
+    this.stops = sortedStops;
+    this.config = cfg;
+    this.state = NewViterbiState(activeDirection);
+  }
+  static NewSnapper(line, stops, cfg) {
+    return new _Snapper(line, stops, cfg);
+  }
+  ctx() {
+    return {
+      line: this.line,
+      segments: this.segments,
+      stops: this.stops,
+      config: this.config,
+      state: this.state
+    };
+  }
+  Snap(point) {
+    const ctx = this.ctx();
+    const distReset = maybeResetSnapDistance(ctx, point);
+    updateSegmentDepartLatch(this.state, point, this.config);
+    const candidates = findCandidates(
+      this.segments,
+      point,
+      this.state.LastPoint,
+      this.state,
+      this.config
+    );
+    if (candidates.length === 0) {
+      const [held, heldBest] = tryHoldLastSegment(ctx, point, "no_candidates");
+      if (held) {
+        let best2 = heldBest;
+        const promoted2 = this.enforceDepartLatch(heldBest, point);
+        if (promoted2) {
+          best2 = promoted2;
+          const updated = resultFromCandidate(ctx, promoted2, point);
+          return markDistanceReset(
+            finishSnap(ctx, [], best2, updated, point),
+            distReset
+          );
+        }
+        return markDistanceReset(
+          finishSnap(ctx, [], best2, held, point),
+          distReset
+        );
+      }
+      return markDistanceReset(
+        {
+          OriginalPoint: point.Point,
+          SnappedPoint: point.Point,
+          SegmentID: "",
+          SegmentOrder: 0,
+          Direction: DirectionUnknown,
+          NearestStopID: "",
+          DistanceMeter: 0,
+          Progress: 0,
+          BusBearing: 0,
+          LineBearing: 0,
+          DirectionDiff: 0,
+          Confidence: 0,
+          IsOffRoute: true,
+          RejectedReason: "no candidates within max snap distance"
+        },
+        distReset
+      );
+    }
+    let best = runViterbiStep(
+      this.state,
+      candidates,
+      this.segments.length,
+      point,
+      this.config
+    );
+    if (!best) {
+      if (this.state.LastBest && this.config.PreventBackwardTransition) {
+        best = candidateOnSegment(
+          ctx,
+          this.state.LastBest.Segment,
+          point
+        );
+      } else {
+        throw ErrNoCandidates;
+      }
+    }
+    best = stabilizeSameSegmentCandidate(ctx, best, point) ?? best;
+    best = preferNearbyOnActiveSegment(ctx, best, point) ?? best;
+    const enforced = this.enforceNextStopBeforeSegmentSwitch(best, point);
+    if (enforced) {
+      best = enforced;
+    }
+    const promoted = this.enforceDepartLatch(best, point);
+    if (promoted) {
+      best = promoted;
+    }
+    if (this.state.LastBest && this.config.PreventBackwardTransition) {
+      const prevOrder = this.state.LastBest.Segment.Order;
+      if (best.Segment.Order < prevOrder && !isLoopWrapTransition(
+        prevOrder,
+        best.Segment.Order,
+        this.segments.length,
+        this.config.Looping
+      )) {
+        best = candidateOnSegment(ctx, this.state.LastBest.Segment, point);
+      }
+    }
+    let result = resultFromCandidate(ctx, best, point);
+    if (shouldClampBackward(ctx, result) || shouldClampMeasureRegression(ctx, result) || shouldClampLateral(ctx, result, point)) {
+      const [clamped] = clampToPreviousSegmentWithMaxDist(
+        ctx,
+        point,
+        this.config.MaxSnapDistanceMeter
+      );
+      if (clamped && this.state.LastBest) {
+        result = clamped;
+        best = candidateOnSegment(ctx, this.state.LastBest.Segment, point);
+      }
+    }
+    if (!result.SegmentID || result.SegmentOrder <= 0) {
+      const [held, heldBest] = tryHoldLastSegment(ctx, point, "empty_segment");
+      if (held) {
+        return markDistanceReset(
+          finishSnap(ctx, candidates, heldBest, held, point),
+          distReset
+        );
+      }
+    }
+    const [wildResult, wildBest] = stabilizeWildGPSJump(ctx, best, point);
+    if (wildResult) {
+      best = wildBest;
+      result = wildResult;
+    }
+    const [capped, capBest] = capForwardSnapAdvance(ctx, best, point);
+    if (capped) {
+      best = capBest;
+      result = capped;
+    }
+    const [contResult, contBest] = applySnapContinuityResult(
+      ctx,
+      best,
+      point,
+      result
+    );
+    if (contResult) {
+      best = contBest;
+      result = contResult;
+    }
+    const [creepResult, creepBest] = ensureForwardCreepWhenStuck(
+      ctx,
+      best,
+      point
+    );
+    if (creepResult) {
+      best = creepBest;
+      result = creepResult;
+    }
+    const resnapped = resnapOnActiveSegmentWhenDrifted(ctx, best, point);
+    if (resnapped && resnapped !== best) {
+      best = resnapped;
+      result = resultFromCandidate(ctx, best, point);
+    }
+    best = enforceForwardSegmentOrder(ctx, best, point) ?? best;
+    if (result && this.state.LastBest && (result.SegmentOrder < this.state.LastBest.Segment.Order || best && best.Segment.Order < this.state.LastBest.Segment.Order && !isLoopWrapTransition(
+      this.state.LastBest.Segment.Order,
+      best.Segment.Order,
+      this.segments.length,
+      this.config.Looping
+    ))) {
+      result = resultFromCandidate(ctx, best, point);
+    }
+    result = finishSnap(ctx, candidates, best, result, point);
+    return markDistanceReset(result, distReset);
+  }
+  enforceNextStopBeforeSegmentSwitch(best, point) {
+    if (!best || !this.state.LastBest) {
+      return null;
+    }
+    if (!this.config.RequireNextStopBeforeSegmentSwitch && !this.config.RequireStopRadiusForSegmentSwitch) {
+      return null;
+    }
+    if (rejectSegmentSwitch(
+      this.state,
+      best,
+      this.segments.length,
+      point,
+      this.config
+    )) {
+      return candidateOnSegment(this.ctx(), this.state.LastBest.Segment, point);
+    }
+    return null;
+  }
+  enforceDepartLatch(best, point) {
+    if (!this.config.RequireStopRadiusForSegmentSwitch || !this.state.LastBest) {
+      return null;
+    }
+    const fromOrder = this.state.LastBest.Segment.Order;
+    if (!forwardDepartLatchActive(this.state, fromOrder)) {
+      return null;
+    }
+    const nextOrder = fromOrder + 1;
+    if (best && best.Segment.Order >= nextOrder) {
+      return null;
+    }
+    const [nextSeg, ok] = segmentWithOrder(this.segments, nextOrder);
+    if (!ok) {
+      return null;
+    }
+    return candidateOnSegment(this.ctx(), nextSeg, point);
+  }
+  Reset() {
+    this.state.LastCandidates = [];
+    this.state.LastBest = null;
+    this.state.LastGood = null;
+    this.state.LastPoint = null;
+    this.state.LastTimestamp = 0;
+    this.state.BranchLock = null;
+    this.state.BranchNormalTicks = 0;
+    this.state.RecentBranchTicks = [];
+    this.state.LastOutputSnapDistanceM = 0;
+    this.state.GrowingSnapDistTicks = 0;
+    this.state.SegmentDepart = {
+      GateSegmentOrder: 0,
+      WasInsideRadius: false,
+      HasDeparted: false
+    };
+  }
+  SetTripDirection(direction) {
+    this.config.TripDirection = direction;
+    this.config.UseTripDirection = direction !== DirectionUnknown;
+    this.state.ActiveDirection = direction;
+  }
+  Segments() {
+    return this.segments.map((s) => ({ ...s, Geometry: [...s.Geometry] }));
+  }
+  Config() {
+    return { ...this.config };
+  }
+  RouteMeasure(order, progress) {
+    return routeMeasure(this.ctx(), order, progress);
+  }
+  PointAtRouteMeasure(order, progress) {
+    const m = this.RouteMeasure(order, progress);
+    const [p] = PointAtMeasure(this.line, m);
+    return p;
+  }
+};
+function NewSnapper(line, stops, cfg) {
+  return Snapper.NewSnapper(line, stops, cfg);
+}
+function SnapResultFromSegment(seg, stops, point, prev, cfg) {
+  const proj = ProjectPointOnLine(seg.Geometry, point.Point);
+  const absMeasure = seg.FromMeasure + proj.Measure;
+  const lineBearing = BearingAtMeasure(seg.Geometry, proj.Measure);
+  const [busBearing, hasBearing] = resolveBusBearing(point, prev, cfg);
+  const weaken = shouldWeakenDirectionValidation(point, prev, cfg);
+  const [, directionDiff] = scoreDirection(
+    busBearing,
+    hasBearing,
+    lineBearing,
+    cfg,
+    weaken
+  );
+  const resolvedBusBearing = hasBearing ? busBearing : lineBearing;
+  const emission = EmissionScore(proj.DistanceMeter, cfg.MaxSnapDistanceMeter);
+  const [dirScore] = scoreDirection(
+    busBearing,
+    hasBearing,
+    lineBearing,
+    cfg,
+    weaken
+  );
+  const tripScore = TripDirectionScore(seg.Direction, cfg.TripDirection);
+  const confidence = clampConfidence(emission * dirScore * tripScore);
+  return {
+    OriginalPoint: point.Point,
+    SnappedPoint: proj.Point,
+    SegmentID: seg.ID,
+    SegmentOrder: seg.Order,
+    Direction: seg.Direction,
+    NearestStopID: nearestStopID(stops, proj.Point),
+    DistanceMeter: proj.DistanceMeter,
+    Progress: segmentProgress(seg, absMeasure),
+    BusBearing: resolvedBusBearing,
+    LineBearing: lineBearing,
+    DirectionDiff: directionDiff,
+    Confidence: confidence,
+    IsOffRoute: proj.DistanceMeter > cfg.MaxSnapDistanceMeter
+  };
+}
+
+exports.BearingAtMeasure = BearingAtMeasure;
+exports.BearingBetween = BearingBetween;
+exports.BearingDiff = BearingDiff;
+exports.BuildSegments = BuildSegments;
+exports.BuildSegmentsFromProjectedStops = BuildSegmentsFromProjectedStops;
+exports.CountOccurrence = CountOccurrence;
+exports.DefaultBranchLockSearchWindowM = DefaultBranchLockSearchWindowM;
+exports.DefaultBranchUnlockNormalTicks = DefaultBranchUnlockNormalTicks;
+exports.DefaultConfig = DefaultConfig;
+exports.DefaultFoldedSegmentMeasureSpreadM = DefaultFoldedSegmentMeasureSpreadM;
+exports.DefaultFoldedSegmentMinViable = DefaultFoldedSegmentMinViable;
+exports.DefaultOffRouteMinConfidence = DefaultOffRouteMinConfidence;
+exports.DefaultOffRoutePolicy = DefaultOffRoutePolicy;
+exports.DefaultOffRouteSoftConfidence = DefaultOffRouteSoftConfidence;
+exports.DefaultOffRouteSoftDistFraction = DefaultOffRouteSoftDistFraction;
+exports.DefaultRouteClampBackwardMinConfidence = DefaultRouteClampBackwardMinConfidence;
+exports.DefaultRouteClampDwellSpeedKmh = DefaultRouteClampDwellSpeedKmh;
+exports.DefaultRouteHoldLastSegmentMaxAgeMs = DefaultRouteHoldLastSegmentMaxAgeMs;
+exports.DefaultRouteHoldLastSegmentMaxDistM = DefaultRouteHoldLastSegmentMaxDistM;
+exports.DefaultRouteHoldLastSegmentMinConfidence = DefaultRouteHoldLastSegmentMinConfidence;
+exports.DefaultRouteMaxForwardSnapMeter = DefaultRouteMaxForwardSnapMeter;
+exports.DefaultRouteMeasureAdvanceSlackMeter = DefaultRouteMeasureAdvanceSlackMeter;
+exports.DefaultRouteMeasureRegressionToleranceMeter = DefaultRouteMeasureRegressionToleranceMeter;
+exports.DefaultRouteNextStopPassToleranceMeter = DefaultRouteNextStopPassToleranceMeter;
+exports.DefaultRouteSegmentSwitchHysteresisLog = DefaultRouteSegmentSwitchHysteresisLog;
+exports.DefaultRouteSegmentSwitchStopRadiusMeter = DefaultRouteSegmentSwitchStopRadiusMeter;
+exports.DefaultRouteSnappedJumpSlackMeter = DefaultRouteSnappedJumpSlackMeter;
+exports.DefaultRouteWildGPSJumpMinMeter = DefaultRouteWildGPSJumpMinMeter;
+exports.DefaultRouteWildGPSJumpMultiplier = DefaultRouteWildGPSJumpMultiplier;
+exports.DefaultRouteWildGPSMaxAdvanceFactor = DefaultRouteWildGPSMaxAdvanceFactor;
+exports.DefaultSnapDistanceGrowMinDeltaM = DefaultSnapDistanceGrowMinDeltaM;
+exports.DefaultSnapDistanceGrowResetTicks = DefaultSnapDistanceGrowResetTicks;
+exports.DefaultSnapDistanceResetMaxMeter = DefaultSnapDistanceResetMaxMeter;
+exports.DefaultSnapDistanceResetMinMeter = DefaultSnapDistanceResetMinMeter;
+exports.DetectLoopClosure = DetectLoopClosure;
+exports.DirectionInbound = DirectionInbound;
+exports.DirectionLoop = DirectionLoop;
+exports.DirectionOutbound = DirectionOutbound;
+exports.DirectionScore = DirectionScore;
+exports.DirectionUnknown = DirectionUnknown;
+exports.DisableBackwardClamp = DisableBackwardClamp;
+exports.DistanceMeter = DistanceMeter;
+exports.EmissionScore = EmissionScore;
+exports.ErrEmptySegments = ErrEmptySegments;
+exports.ErrInsufficientStops = ErrInsufficientStops;
+exports.ErrInvalidLine = ErrInvalidLine;
+exports.ErrInvalidMeasureRange = ErrInvalidMeasureRange;
+exports.ErrNoCandidates = ErrNoCandidates;
+exports.ErrStopMeasureNotMonotonic = ErrStopMeasureNotMonotonic;
+exports.EtaSnapReliableForPublish = EtaSnapReliableForPublish;
+exports.EtaSnapUnreliable = EtaSnapUnreliable;
+exports.FindNearestProjectionAfterMeasure = FindNearestProjectionAfterMeasure;
+exports.FindProjectionCandidates = FindProjectionCandidates;
+exports.FindProjectionNearMeasure = FindProjectionNearMeasure;
+exports.ForwardProjectionOnSegment = ForwardProjectionOnSegment;
+exports.IsLoopRoute = IsLoopRoute;
+exports.IsSameStop = IsSameStop;
+exports.LineLengthMeter = LineLengthMeter;
+exports.LiveBusSnapConfig = LiveBusSnapConfig;
+exports.MapOffRoute = MapOffRoute;
+exports.NewSnapper = NewSnapper;
+exports.NewViterbiState = NewViterbiState;
+exports.PointAtMeasure = PointAtMeasure;
+exports.ProjectPointOnLine = ProjectPointOnLine;
+exports.ProjectPointOnLineContinued = ProjectPointOnLineContinued;
+exports.ProjectStopForwardOnly = ProjectStopForwardOnly;
+exports.ProjectStopNearMeasure = ProjectStopNearMeasure;
+exports.ProjectStopsSequential = ProjectStopsSequential;
+exports.RecommendedClampBackwardMinConfidence = RecommendedClampBackwardMinConfidence;
+exports.RecommendedClampDwellSpeedKmh = RecommendedClampDwellSpeedKmh;
+exports.RecommendedLoopClosureToleranceMeter = RecommendedLoopClosureToleranceMeter;
+exports.RecommendedLoopNextStopPassToleranceMeter = RecommendedLoopNextStopPassToleranceMeter;
+exports.RecommendedMaxBearingDiffDegree = RecommendedMaxBearingDiffDegree;
+exports.RecommendedMaxSnapDistanceMeter = RecommendedMaxSnapDistanceMeter;
+exports.RecommendedMeasureAdvanceSlackMeter = RecommendedMeasureAdvanceSlackMeter;
+exports.RecommendedMeasureRegressionToleranceMeter = RecommendedMeasureRegressionToleranceMeter;
+exports.RecommendedMinMovementMeter = RecommendedMinMovementMeter;
+exports.RecommendedSegmentSwitchHysteresisLog = RecommendedSegmentSwitchHysteresisLog;
+exports.RecommendedSegmentSwitchStopRadiusMeter = RecommendedSegmentSwitchStopRadiusMeter;
+exports.RecommendedSnapDistanceGrowMinDeltaM = RecommendedSnapDistanceGrowMinDeltaM;
+exports.RecommendedSnapDistanceGrowResetTicks = RecommendedSnapDistanceGrowResetTicks;
+exports.RecommendedSnapDistanceResetMaxMeter = RecommendedSnapDistanceResetMaxMeter;
+exports.RecommendedSnapDistanceResetMinMeter = RecommendedSnapDistanceResetMinMeter;
+exports.RecommendedSnappedJumpSlackMeter = RecommendedSnappedJumpSlackMeter;
+exports.RouteSnapConfig = RouteSnapConfig;
+exports.RouteSnapParamsOption = RouteSnapParamsOption;
+exports.SliceLineByMeasure = SliceLineByMeasure;
+exports.SnapDegraded = SnapDegraded;
+exports.SnapResultFromSegment = SnapResultFromSegment;
+exports.SnapToLineError = SnapToLineError;
+exports.Snapper = Snapper;
+exports.TransitionScore = TransitionScore;
+exports.TripDirectionScore = TripDirectionScore;
+exports.WithBranchLockSearchWindowM = WithBranchLockSearchWindowM;
+exports.WithBranchUnlockNormalTicks = WithBranchUnlockNormalTicks;
+exports.WithClampBackwardMinConfidence = WithClampBackwardMinConfidence;
+exports.WithClampDwellSpeedKmh = WithClampDwellSpeedKmh;
+exports.WithFoldedSegmentBranchLock = WithFoldedSegmentBranchLock;
+exports.WithFoldedSegmentMeasureSpreadM = WithFoldedSegmentMeasureSpreadM;
+exports.WithFoldedSegmentMinViable = WithFoldedSegmentMinViable;
+exports.WithHoldLastSegmentMaxAgeMs = WithHoldLastSegmentMaxAgeMs;
+exports.WithHoldLastSegmentMaxDistM = WithHoldLastSegmentMaxDistM;
+exports.WithHoldLastSegmentMinConfidence = WithHoldLastSegmentMinConfidence;
+exports.WithHoldLastSegmentOnMiss = WithHoldLastSegmentOnMiss;
+exports.WithLoopClosureTolerance = WithLoopClosureTolerance;
+exports.WithLooping = WithLooping;
+exports.WithMaxForwardSnapMeter = WithMaxForwardSnapMeter;
+exports.WithMeasureAdvanceSlack = WithMeasureAdvanceSlack;
+exports.WithMeasureRegressionTolerance = WithMeasureRegressionTolerance;
+exports.WithNextStopPassToleranceMeter = WithNextStopPassToleranceMeter;
+exports.WithNoBackwardSnap = WithNoBackwardSnap;
+exports.WithPreventBackwardTransition = WithPreventBackwardTransition;
+exports.WithRequireNextStopBeforeSegmentSwitch = WithRequireNextStopBeforeSegmentSwitch;
+exports.WithRequireStopRadiusForSegmentSwitch = WithRequireStopRadiusForSegmentSwitch;
+exports.WithRouteSnapParams = WithRouteSnapParams;
+exports.WithSegmentSwitchHysteresisLog = WithSegmentSwitchHysteresisLog;
+exports.WithSegmentSwitchStopRadiusMeter = WithSegmentSwitchStopRadiusMeter;
+exports.WithSnapContinuityFromPrevious = WithSnapContinuityFromPrevious;
+exports.WithSnapDistanceGrowMinDeltaM = WithSnapDistanceGrowMinDeltaM;
+exports.WithSnapDistanceGrowResetTicks = WithSnapDistanceGrowResetTicks;
+exports.WithSnapDistanceResetMaxMeter = WithSnapDistanceResetMaxMeter;
+exports.WithSnapDistanceResetMinMeter = WithSnapDistanceResetMinMeter;
+exports.WithSnapDistanceResetOnGrow = WithSnapDistanceResetOnGrow;
+exports.WithSnappedJumpSlack = WithSnappedJumpSlack;
+exports.WithWildGPSJumpMinMeter = WithWildGPSJumpMinMeter;
+exports.WithWildGPSJumpMultiplier = WithWildGPSJumpMultiplier;
+exports.WithWildGPSMaxAdvanceFactor = WithWildGPSMaxAdvanceFactor;
+exports.WithWildGPSStabilize = WithWildGPSStabilize;
+exports.clampConfidence = clampConfidence;
+exports.confidenceFromScores = confidenceFromScores;
+exports.detectLoopFromStops = detectLoopFromStops;
+exports.findCandidates = findCandidates;
+exports.forwardDepartLatchActive = forwardDepartLatchActive;
+exports.hasPassedSegmentDestination = hasPassedSegmentDestination;
+exports.isLoopWrapTransition = isLoopWrapTransition;
+exports.logScore = logScore;
+exports.nearestStopID = nearestStopID;
+exports.pickNearestForwardCandidate = pickNearestForwardCandidate;
+exports.projectOntoSegment = projectOntoSegment;
+exports.rejectBackwardCandidate = rejectBackwardCandidate;
+exports.rejectSegmentSwitch = rejectSegmentSwitch;
+exports.runViterbiStep = runViterbiStep;
+exports.segmentProgress = segmentProgress;
+exports.segmentWithOrder = segmentWithOrder;
+exports.sortStopsByOrder = sortStopsByOrder;
+exports.updateSegmentDepartLatch = updateSegmentDepartLatch;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map