동작은 단계의 끝에 있어

    static func navRoute(from route: MKRoute, origin: Coordinate, destination: Place) -> NavRoute {
      let polyline = Polyline(Self.coordinates(of: route.polyline))
      var steps: [NavStep] = []
      var along = 0.0
      for step in route.steps {
        // A step's instruction is the maneuver at the END of its path (see
        // `NavStep`); pin that end on the whole route, never moving backwards.
        let points = Self.coordinates(of: step.polyline)
        var maneuverAlong = along + step.distance
        if let end = points.last {
          let window = along...(along + step.distance * 1.5 + 200)
          if let match = polyline.project(end, within: window, preferAlong: along + step.distance),
            match.lateral < 60
          {
            maneuverAlong = max(along, match.distanceAlong)
          }
        }
        maneuverAlong = min(maneuverAlong, polyline.length)
        steps.append(
          NavStep(
            instruction: step.instructions, distance: step.distance, maneuverAlong: maneuverAlong,
            notice: step.notice))
        along = maneuverAlong
      }

// A minimal sketch: two readings of the same provider steps. Each step is
// (instruction, metres driven on that step). The numbers echo the measured
// shape (1.5 km to an interchange, a short step to a turn, 109 m to arrive)
// but the route is made up.
let steps: [(instruction: String, distance: Double)] = [
  ("", 0),                               // the departure placeholder
  ("keep left at the interchange", 1500),
  ("turn right", 150),
  ("arrive", 109),
]

// Reading A (Pathfinder's NavStep.maneuverAlong): the maneuver happens at
// the END of the step's path, so its position is the running total.
// Reading B (the tempting one): the maneuver happens where the step starts.
var along = 0.0
var atEnd: [Double] = [], atStart: [Double] = []
for step in steps {
  atStart.append(along)
  along += step.distance
  atEnd.append(along)
}

for (i, step) in steps.enumerated() where !step.instruction.isEmpty {
  let early = atEnd[i] - atStart[i]
  print("\(step.instruction): end-reading \(Int(atEnd[i])) m, start-reading \(Int(atStart[i])) m (\(Int(early)) m early)")
}

// The car has just done the keep-left: 1500 m along.
let progress = 1500.0
let i = 2
print("at \(Int(progress)) m, '\(steps[i].instruction)' is \(Int(atEnd[i] - progress)) m ahead (A) or \(Int(atStart[i] - progress)) m ahead (B)")
// keep left at the interchange: end-reading 1500 m, start-reading 0 m (1500 m early)
// turn right: end-reading 1650 m, start-reading 1500 m (150 m early)
// arrive: end-reading 1759 m, start-reading 1650 m (109 m early)
// at 1500 m, 'turn right' is 150 m ahead (A) or 0 m ahead (B)

  /// The heading the map should face.
  ///
  /// GPS course means something only while moving; stopped at a light it is
  /// noise or nothing, and the old code fell back to north, spinning the map.
  /// Driving: course when moving, else the road's direction on the route,
  /// else where the map already faced. Walking: course at a brisk pace, else
  /// the compass (a person turns on the spot; the phone knows), else the
  /// route, else the previous heading.
  public static func heading(
    mode: TravelMode, course: Double?, speed: Double?, compass: Double?, routeBearing: Double?, previous: Double?
  ) -> Double? {
    let moving = (speed ?? 0) >= (mode == .walking ? 1.8 : 2.5)
    if moving, let course { return Geo.normalized(course) }
    let order: [Double?] =
      mode == .walking ? [compass, routeBearing, previous] : [routeBearing, previous, compass]
    return order.compactMap { $0 }.first.map(Geo.normalized)
  }