@mapslibvn/core 0.4.0 → 0.5.0

package/dist/index.js

@@ -95,6 +95,7 @@ function poiSourceClause(arrayExpr) {
 }
 
 // src/client.ts
+var latLng = ([lat, lng]) => `${lat},${lng}`;
 function createClient(options) {
   const baseUrl = options.baseUrl.replace(/\/+$/, "");
   const poiSources = normalizePoiSources(options.poiSources ?? DEFAULT_POI_SOURCES);
@@ -177,6 +178,15 @@ function createClient(options) {
       limit: opts.limit
     }),
     reverse: (lat, lng) => get("/v1/reverse", { lat, lng, sources }),
+    /** Chỉ đường (spec dẫn đường A). Response dùng [lng, lat]; tham số vào dùng [lat, lng]. */
+    directions: (opts) => get("/v1/directions", {
+      from: latLng(opts.from),
+      to: latLng(opts.to),
+      via: opts.via && opts.via.length > 0 ? opts.via.map(latLng).join(";") : void 0,
+      mode: opts.mode,
+      lang: opts.lang,
+      alternatives: opts.alternatives === void 0 ? void 0 : opts.alternatives ? 1 : 0
+    }),
     /** Gửi đóng góp/sửa POI (spec 6.1). Khoá phải có scope edits:write. */
     suggestEdit: (edit) => post("/v1/edits", edit)
   };
@@ -594,6 +604,10 @@ function adminAliasKeys(input) {
 
 // src/style-transform.ts
 var POI_LAYER_ID = "poi";
+var FIRST_SYMBOL_LAYER_ID = {
+  light: "road_one_way_arrow",
+  dark: "water_name"
+};
 var SOVEREIGNTY_LABEL_ID = "sovereignty-label";
 function isPoiStyleLayer(layer) {
   return layer.id === POI_LAYER_ID || layer.source === "poi";
@@ -792,39 +806,872 @@ function looksLikeTelex(normalized) {
 function foldTelex(normalized) {
   return normalized.replace(/aa/g, "a").replace(/ee/g, "e").replace(/oo/g, "o").replace(/dd/g, "d").replace(/aw/g, "a").replace(/ow/g, "o").replace(/uw/g, "u").replace(/([aeiouy](?:ch|ng|nh|[cmnpt])?)[sfrxj]\b/g, "$1").replace(/([a-z])[1-9]\b/g, "$1").replace(/\s+/g, " ").trim();
 }
+
+// src/polyline.ts
+function decodePolyline6(encoded) {
+  const coords = [];
+  let index = 0;
+  let lat = 0;
+  let lng = 0;
+  const next = () => {
+    let result = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = encoded.charCodeAt(index++) - 63;
+      result |= (byte & 31) << shift;
+      shift += 5;
+    } while (byte >= 32);
+    return result & 1 ? ~(result >> 1) : result >> 1;
+  };
+  while (index < encoded.length) {
+    lat += next();
+    lng += next();
+    coords.push([lng / 1e6, lat / 1e6]);
+  }
+  return coords;
+}
+function encodePolyline6(coords) {
+  let out = "";
+  let prevLat = 0;
+  let prevLng = 0;
+  for (const [lng, lat] of coords) {
+    const iLat = Math.round(lat * 1e6);
+    const iLng = Math.round(lng * 1e6);
+    out += encodeValue(iLat - prevLat) + encodeValue(iLng - prevLng);
+    prevLat = iLat;
+    prevLng = iLng;
+  }
+  return out;
+}
+function encodeValue(value) {
+  let v = value < 0 ? ~(value << 1) : value << 1;
+  let out = "";
+  while (v >= 32) {
+    out += String.fromCharCode((32 | v & 31) + 63);
+    v >>= 5;
+  }
+  return out + String.fromCharCode(v + 63);
+}
+
+// src/maneuver.ts
+var MANEUVER_KINDS = [
+  "depart",
+  "arrive",
+  "continue",
+  "slight_right",
+  "slight_left",
+  "turn_right",
+  "turn_left",
+  "sharp_right",
+  "sharp_left",
+  "uturn_right",
+  "uturn_left",
+  "ramp_straight",
+  "ramp_right",
+  "ramp_left",
+  "exit_right",
+  "exit_left",
+  "keep_right",
+  "keep_left",
+  "merge",
+  "merge_right",
+  "merge_left",
+  "roundabout_enter",
+  "roundabout_exit",
+  "ferry_enter",
+  "ferry_exit",
+  "elevator",
+  "steps",
+  "escalator",
+  "building_enter",
+  "building_exit",
+  "other"
+];
+var VALHALLA_MANEUVER_KIND = {
+  1: "depart",
+  2: "depart",
+  3: "depart",
+  4: "arrive",
+  5: "arrive",
+  6: "arrive",
+  7: "continue",
+  8: "continue",
+  9: "slight_right",
+  10: "turn_right",
+  11: "sharp_right",
+  12: "uturn_right",
+  13: "uturn_left",
+  14: "sharp_left",
+  15: "turn_left",
+  16: "slight_left",
+  17: "ramp_straight",
+  18: "ramp_right",
+  19: "ramp_left",
+  20: "exit_right",
+  21: "exit_left",
+  22: "continue",
+  23: "keep_right",
+  24: "keep_left",
+  25: "merge",
+  26: "roundabout_enter",
+  27: "roundabout_exit",
+  28: "ferry_enter",
+  29: "ferry_exit",
+  37: "merge_right",
+  38: "merge_left",
+  39: "elevator",
+  40: "steps",
+  41: "escalator",
+  42: "building_enter",
+  43: "building_exit"
+};
+function maneuverKindFromValhalla(type) {
+  return VALHALLA_MANEUVER_KIND[type] ?? "other";
+}
+
+// src/navigation/types.ts
+var NAVIGATION_THRESHOLDS = {
+  walk: {
+    offRoute_m: 25,
+    offRouteFixes: 3,
+    offRouteSeconds: 5,
+    maxAccuracy_m: 60,
+    approach_m: 40,
+    pre_m: 15,
+    arrive_m: 15,
+    rerouteCooldown_s: 15,
+    rerouteMaxFailures: 3
+  },
+  motorbike: {
+    offRoute_m: 40,
+    offRouteFixes: 3,
+    offRouteSeconds: 5,
+    maxAccuracy_m: 100,
+    approach_m: 200,
+    pre_m: 50,
+    arrive_m: 25,
+    rerouteCooldown_s: 15,
+    rerouteMaxFailures: 3
+  },
+  car: {
+    offRoute_m: 50,
+    offRouteFixes: 3,
+    offRouteSeconds: 5,
+    maxAccuracy_m: 100,
+    approach_m: 400,
+    pre_m: 80,
+    arrive_m: 30,
+    rerouteCooldown_s: 15,
+    rerouteMaxFailures: 3
+  }
+};
+
+// src/navigation/geometry.ts
+var EARTH_RADIUS_M = 63710088e-1;
+var M_PER_DEG_LAT = Math.PI / 180 * EARTH_RADIUS_M;
+var toRad = (deg) => deg * Math.PI / 180;
+var toDeg = (rad) => rad * 180 / Math.PI;
+function haversineM(a, b) {
+  const dLat = toRad(b[1] - a[1]);
+  const dLng = toRad(b[0] - a[0]);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a[1])) * Math.cos(toRad(b[1])) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function bearingDeg(a, b) {
+  const phi1 = toRad(a[1]);
+  const phi2 = toRad(b[1]);
+  const dLambda = toRad(b[0] - a[0]);
+  const y = Math.sin(dLambda) * Math.cos(phi2);
+  const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(dLambda);
+  return (toDeg(Math.atan2(y, x)) + 360) % 360;
+}
+function angleDiffDeg(a, b) {
+  const d = Math.abs(((a - b) % 360 + 360) % 360);
+  return d > 180 ? 360 - d : d;
+}
+function projectOnSegment(p, a, b) {
+  const mPerDegLng = M_PER_DEG_LAT * Math.cos(toRad(a[1]));
+  const bx = (b[0] - a[0]) * mPerDegLng;
+  const by = (b[1] - a[1]) * M_PER_DEG_LAT;
+  const px = (p[0] - a[0]) * mPerDegLng;
+  const py = (p[1] - a[1]) * M_PER_DEG_LAT;
+  const len2 = bx * bx + by * by;
+  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, (px * bx + py * by) / len2));
+  const qx = bx * t;
+  const qy = by * t;
+  const point = t === 1 ? [b[0], b[1]] : [a[0] + qx / mPerDegLng, a[1] + qy / M_PER_DEG_LAT];
+  return { t, point, distance_m: Math.hypot(px - qx, py - qy) };
+}
+function cumulativeDistances(coords) {
+  const cum = [];
+  let total = 0;
+  for (let i = 0; i < coords.length; i++) {
+    const prev = coords[i - 1];
+    const cur = coords[i];
+    if (i > 0 && prev && cur) total += haversineM(prev, cur);
+    cum.push(total);
+  }
+  return cum;
+}
+
+// src/navigation/progress.ts
+function buildRouteIndex(route) {
+  const coords = decodePolyline6(route.geometry);
+  const cum = cumulativeDistances(coords);
+  const total_m = cum[cum.length - 1] ?? 0;
+  const at = (vertex) => cum[Math.min(Math.max(vertex, 0), cum.length - 1)] ?? 0;
+  const steps = [];
+  route.legs.forEach((leg, legIndex) => {
+    leg.steps.forEach((step, indexInLeg) => {
+      const begin_m = at(step.shape_begin);
+      steps.push({ step, legIndex, indexInLeg, begin_m, end_m: begin_m });
+    });
+  });
+  for (let i = 0; i < steps.length; i++) {
+    const current = steps[i];
+    if (current) current.end_m = steps[i + 1]?.begin_m ?? total_m;
+  }
+  return { coords, cum, total_m, steps, legBegin_m: route.legs.map((leg) => at(leg.shape_offset)) };
+}
+function stepAt(index, along_m) {
+  const { steps, total_m } = index;
+  if (steps.length === 0) return 0;
+  if (along_m >= total_m) return steps.length - 1;
+  let found = 0;
+  for (let i = 0; i < steps.length; i++) {
+    const s = steps[i];
+    if (!s) continue;
+    if (s.begin_m > along_m) break;
+    if (along_m < s.end_m) {
+      found = i;
+      break;
+    }
+    found = i;
+  }
+  return found;
+}
+function progressAt(index, along_m) {
+  const clamped = Math.max(0, Math.min(along_m, index.total_m));
+  const stepIndex = stepAt(index, clamped);
+  const current = index.steps[stepIndex];
+  const next = index.steps[stepIndex + 1];
+  let remaining_s = 0;
+  if (current) {
+    const length = current.end_m - current.begin_m;
+    const fraction = length > 0 ? Math.max(0, Math.min(1, (current.end_m - clamped) / length)) : 0;
+    remaining_s += fraction * current.step.duration_s;
+  }
+  for (let i = stepIndex + 1; i < index.steps.length; i++) {
+    remaining_s += index.steps[i]?.step.duration_s ?? 0;
+  }
+  return {
+    stepIndex,
+    legIndex: current?.legIndex ?? 0,
+    distanceToStep_m: next ? Math.max(0, next.begin_m - clamped) : 0,
+    remaining_m: Math.max(0, index.total_m - clamped),
+    remaining_s: Math.round(remaining_s)
+  };
+}
+
+// src/navigation/snap.ts
+var TIE_M = 10;
+var LOOKBACK_SEGMENTS = 2;
+function snapToRoute(index, p, opts) {
+  const { coords, cum } = index;
+  const segments = coords.length - 1;
+  if (segments < 1) return null;
+  let lo = 0;
+  let hi = segments - 1;
+  if (opts.fromShapeIndex !== null) {
+    const from = Math.max(0, Math.min(opts.fromShapeIndex, segments - 1));
+    lo = Math.max(0, from - LOOKBACK_SEGMENTS);
+    const limit = (cum[from] ?? 0) + opts.window_m;
+    hi = from;
+    for (let i = from + 1; i < segments; i++) {
+      if ((cum[i] ?? 0) <= limit) hi = i;
+      else break;
+    }
+  }
+  const heading = typeof opts.heading === "number" && Number.isFinite(opts.heading) ? opts.heading : null;
+  let best = null;
+  for (let i = lo; i <= hi; i++) {
+    const a = coords[i];
+    const b = coords[i + 1];
+    if (!a || !b) continue;
+    const proj = projectOnSegment(p, a, b);
+    const segStart = cum[i] ?? 0;
+    const segEnd = cum[i + 1] ?? segStart;
+    const candidate = {
+      shapeIndex: i,
+      t: proj.t,
+      point: proj.point,
+      distance_m: proj.distance_m,
+      along_m: segStart + proj.t * (segEnd - segStart)
+    };
+    if (!best) {
+      best = candidate;
+      continue;
+    }
+    const diff = candidate.distance_m - best.distance_m;
+    const adjacent = candidate.shapeIndex - best.shapeIndex <= 1;
+    if (!adjacent && Math.abs(diff) <= TIE_M) {
+      best = preferByHeadingOrFurther(coords, best, candidate, heading);
+    } else if (diff < 0) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function segmentBearing(coords, shapeIndex) {
+  const a = coords[shapeIndex];
+  const b = coords[shapeIndex + 1];
+  return a && b ? bearingDeg(a, b) : 0;
+}
+function preferByHeadingOrFurther(coords, current, candidate, heading) {
+  if (heading === null) return candidate;
+  const dCurrent = angleDiffDeg(segmentBearing(coords, current.shapeIndex), heading);
+  const dCandidate = angleDiffDeg(segmentBearing(coords, candidate.shapeIndex), heading);
+  return dCandidate <= dCurrent ? candidate : current;
+}
+
+// src/navigation/announce.ts
+var viNumber = (value) => value.replace(".", ",");
+function formatDistance(m, lang = "vi") {
+  const vi = lang === "vi";
+  if (m < 1e3) {
+    const n2 = Math.max(0, Math.round(m));
+    return vi ? `${n2} m\xE9t` : `${n2} meters`;
+  }
+  const km = m / 1e3;
+  if (km < 10) {
+    const s = km.toFixed(1);
+    return vi ? `${viNumber(s)} ki-l\xF4-m\xE9t` : `${s} kilometers`;
+  }
+  const n = Math.round(km);
+  return vi ? `${n} ki-l\xF4-m\xE9t` : `${n} kilometers`;
+}
+function formatDistanceShort(m) {
+  if (m < 1e3) return `${Math.max(0, Math.round(m))} m`;
+  const km = m / 1e3;
+  return km < 10 ? `${viNumber(km.toFixed(1))} km` : `${Math.round(km)} km`;
+}
+function roundForSpeech(m) {
+  if (m >= 200) return Math.round(m / 50) * 50;
+  return Math.max(10, Math.round(m / 10) * 10);
+}
+function lowerFirst(text) {
+  return text.length === 0 ? text : text.charAt(0).toLowerCase() + text.slice(1);
+}
+function composeApproach(distance_m, step, lang) {
+  const cue = step.verbal_alert ?? step.verbal_pre;
+  if (!cue) return null;
+  const d = formatDistance(roundForSpeech(distance_m), lang);
+  return lang === "vi" ? `Trong ${d} n\u1EEFa, ${lowerFirst(cue)}` : `In ${d}, ${lowerFirst(cue)}`;
+}
+function planAnnouncements(p, th, lang, announced, stepChanged) {
+  const out = [];
+  const push = (stepIndex, kind, text, priority) => {
+    if (!text) return;
+    const key = `${stepIndex}:${kind}`;
+    if (announced.has(key)) return;
+    announced.add(key);
+    out.push({ text, kind, stepIndex, priority });
+  };
+  const longEnough = p.step.distance_m > th.approach_m + th.pre_m;
+  if (p.step.kind === "depart") push(p.stepIndex, "depart", p.step.verbal_pre, 3);
+  else if (stepChanged && longEnough) push(p.stepIndex, "post", p.step.verbal_post, 1);
+  const next = p.nextStep;
+  if (next) {
+    const nextIndex = p.stepIndex + 1;
+    const d = p.distanceToStep_m;
+    if (d <= th.approach_m && longEnough) {
+      push(nextIndex, "approach", composeApproach(d, next, lang), 2);
+    }
+    if (d <= th.pre_m)
+      push(nextIndex, next.kind === "arrive" ? "arrive" : "pre", next.verbal_pre, 3);
+  }
+  return out;
+}
+
+// src/navigation/simulate.ts
+var SIMULATE_DEFAULT_SPEED_MPS = {
+  walk: 1.4,
+  motorbike: 8,
+  car: 12
+};
+var M_PER_DEG_LAT2 = Math.PI / 180 * 63710088e-1;
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function simulateFixes(route, opts = {}) {
+  const coords = decodePolyline6(route.geometry);
+  const cum = cumulativeDistances(coords);
+  const total = cum[cum.length - 1] ?? 0;
+  const speed = opts.speed_mps ?? SIMULATE_DEFAULT_SPEED_MPS[route.mode];
+  const interval = opts.interval_s ?? 1;
+  const accuracy = opts.accuracy_m ?? 8;
+  const jitter = opts.jitter_m ?? 0;
+  const start = opts.start_ms ?? 17e11;
+  const rand = mulberry32(opts.seed ?? 1);
+  const stepM = speed * interval;
+  if (coords.length === 0 || stepM <= 0) return [];
+  const fixes = [];
+  let segment = 0;
+  const distances = [];
+  for (let d = 0; d < total; d += stepM) distances.push(d);
+  distances.push(total);
+  distances.forEach((d, k) => {
+    while (segment < coords.length - 2 && (cum[segment + 1] ?? 0) < d) segment += 1;
+    const a = coords[segment];
+    const b = coords[segment + 1] ?? a;
+    if (!a || !b) return;
+    const segStart = cum[segment] ?? 0;
+    const segLen = (cum[segment + 1] ?? segStart) - segStart;
+    const t = segLen > 0 ? Math.min(1, (d - segStart) / segLen) : 0;
+    let lng = a[0] + (b[0] - a[0]) * t;
+    let lat = a[1] + (b[1] - a[1]) * t;
+    if (jitter > 0) {
+      const angle = rand() * 2 * Math.PI;
+      const radius = jitter * Math.sqrt(rand());
+      lat += radius * Math.cos(angle) / M_PER_DEG_LAT2;
+      lng += radius * Math.sin(angle) / (M_PER_DEG_LAT2 * Math.cos(lat * Math.PI / 180));
+    }
+    fixes.push({
+      lng,
+      lat,
+      accuracy_m: accuracy,
+      heading: bearingDeg(a, b),
+      speed_mps: speed,
+      timestamp: start + k * interval * 1e3
+    });
+  });
+  return fixes;
+}
+
+// src/navigation/navigator.ts
+var DEFAULT_ACCURACY_M = 10;
+var WINDOW_BASE_M = 300;
+var WINDOW_SPEED_MPS = 40;
+var WINDOW_MAX_M = 3e3;
+var ARRIVE_NEAR_REMAINING_M = 150;
+var MOVING_SPEED_MPS = 1;
+function buildState(response, routeIndex, override) {
+  const route = response.routes[routeIndex];
+  if (!route) throw new Error(`createNavigator: response kh\xF4ng c\xF3 routes[${routeIndex}]`);
+  return {
+    response,
+    routeIndex,
+    route,
+    index: buildRouteIndex(route),
+    th: { ...NAVIGATION_THRESHOLDS[route.mode], ...override }
+  };
+}
+function createNavigator(opts) {
+  const rerouteMode = opts.reroute ?? "auto";
+  const provider = opts.provider;
+  if (rerouteMode === "auto" && !provider) {
+    throw new Error("createNavigator: reroute 'auto' c\u1EA7n provider (v\xED d\u1EE5 client c\u1EE7a createClient)");
+  }
+  const lang = opts.lang ?? "vi";
+  let rs = buildState(opts.response, opts.routeIndex ?? 0, opts.thresholds);
+  let status = "idle";
+  let progress = null;
+  let last = null;
+  let maxAlong_m = 0;
+  let offCount = 0;
+  let offSince = null;
+  let backCount = 0;
+  let announced = /* @__PURE__ */ new Set();
+  let rerouteAttempts = 0;
+  let lastRerouteAt = null;
+  let inflight = false;
+  let rerouteToken = 0;
+  let rerouteReason = null;
+  const listeners = {
+    status: /* @__PURE__ */ new Set(),
+    progress: /* @__PURE__ */ new Set(),
+    step: /* @__PURE__ */ new Set(),
+    waypoint: /* @__PURE__ */ new Set(),
+    offRoute: /* @__PURE__ */ new Set(),
+    reroute: /* @__PURE__ */ new Set(),
+    rerouteFailed: /* @__PURE__ */ new Set(),
+    announce: /* @__PURE__ */ new Set(),
+    arrive: /* @__PURE__ */ new Set()
+  };
+  const emit = (k, e) => {
+    for (const fn of listeners[k]) fn(e);
+  };
+  const setStatus = (next) => {
+    if (next === status) return;
+    const previous = status;
+    status = next;
+    emit("status", { status, previous });
+  };
+  const resetTracking = () => {
+    last = null;
+    maxAlong_m = 0;
+    offCount = 0;
+    offSince = null;
+    backCount = 0;
+    announced = /* @__PURE__ */ new Set();
+  };
+  const applyRoute = (response, routeIndex) => {
+    rs = buildState(response, routeIndex, opts.thresholds);
+    resetTracking();
+    progress = null;
+  };
+  const destinationLatLng = () => {
+    const w = rs.response.waypoints[rs.response.waypoints.length - 1];
+    const end = rs.index.coords[rs.index.coords.length - 1];
+    const [lng, lat] = w ? w.location : end ?? [0, 0];
+    return [lat, lng];
+  };
+  const rerouteRequest = (fix, legIndex) => {
+    const via = rs.response.waypoints.slice(legIndex + 1, -1).map((w) => [w.location[1], w.location[0]]);
+    const request = {
+      from: [fix.lat, fix.lng],
+      to: destinationLatLng(),
+      mode: rs.route.mode,
+      lang,
+      alternatives: false
+    };
+    if (via.length > 0) request.via = via;
+    return request;
+  };
+  async function runReroute(reason, fix, legIndex) {
+    if (!provider) return;
+    const token = ++rerouteToken;
+    inflight = true;
+    rerouteReason = reason;
+    lastRerouteAt = fix.timestamp;
+    setStatus("rerouting");
+    try {
+      const next = await provider.directions(rerouteRequest(fix, legIndex));
+      inflight = false;
+      if (token !== rerouteToken || status !== "rerouting") return;
+      rerouteAttempts = 0;
+      applyRoute(next, 0);
+      emit("reroute", { reason, response: next });
+      setStatus("navigating");
+    } catch (error) {
+      inflight = false;
+      if (token !== rerouteToken) return;
+      rerouteAttempts += 1;
+      if (status === "rerouting") setStatus("off_route");
+      emit("rerouteFailed", {
+        error,
+        attempts: rerouteAttempts,
+        final: rerouteAttempts >= rs.th.rerouteMaxFailures
+      });
+    }
+  }
+  const maybeAutoReroute = (fix, legIndex) => {
+    if (rerouteMode !== "auto" || !provider || inflight) return;
+    if (rerouteAttempts >= rs.th.rerouteMaxFailures) return;
+    if (lastRerouteAt !== null && fix.timestamp - lastRerouteAt < rs.th.rerouteCooldown_s * 1e3) {
+      return;
+    }
+    void runReroute("off_route", fix, legIndex);
+  };
+  const segmentBearing2 = (shapeIndex) => {
+    const a = rs.index.coords[shapeIndex];
+    const b = rs.index.coords[shapeIndex + 1];
+    return a && b ? bearingDeg(a, b) : 0;
+  };
+  function update(fix) {
+    if (status === "arrived" || status === "stopped") return;
+    const accuracy = fix.accuracy_m ?? DEFAULT_ACCURACY_M;
+    if (accuracy > rs.th.maxAccuracy_m) return;
+    const prev = last;
+    if (prev && fix.timestamp <= prev.fix.timestamp) return;
+    if (status === "idle") setStatus("navigating");
+    const dt_s = prev ? (fix.timestamp - prev.fix.timestamp) / 1e3 : 0;
+    const window_m = Math.min(WINDOW_MAX_M, WINDOW_BASE_M + WINDOW_SPEED_MPS * dt_s);
+    const here = [fix.lng, fix.lat];
+    const anchorShapeIndex = prev ? prev.shapeIndex : null;
+    const snap = snapToRoute(rs.index, here, {
+      fromShapeIndex: anchorShapeIndex,
+      window_m,
+      heading: fix.heading
+    });
+    if (!snap) return;
+    let along_m = snap.along_m;
+    let skippedViaStep = null;
+    const currentLeg = prev?.legIndex ?? 0;
+    const nextLegBegin = rs.index.legBegin_m[currentLeg + 1];
+    const nextVia = rs.response.waypoints[currentLeg + 1];
+    if (nextLegBegin !== void 0 && nextVia && currentLeg + 1 < rs.route.legs.length && along_m < nextLegBegin && haversineM(here, nextVia.snapped) <= rs.th.arrive_m) {
+      along_m = nextLegBegin;
+      skippedViaStep = rs.index.steps.find((s) => s.legIndex === currentLeg && s.step.kind === "arrive") ?? null;
+    }
+    const threshold = Math.max(rs.th.offRoute_m, 1.5 * accuracy);
+    const perpendicularOk = snap.distance_m <= threshold;
+    if (perpendicularOk && prev && along_m < maxAlong_m - rs.th.offRoute_m) backCount += 1;
+    else backCount = 0;
+    const onRoute = perpendicularOk && backCount < rs.th.offRouteFixes;
+    if (onRoute) {
+      offCount = 0;
+      offSince = null;
+      maxAlong_m = prev ? Math.max(maxAlong_m, along_m) : along_m;
+      if (status === "off_route" || status === "rerouting" && rerouteReason === "off_route") {
+        rerouteAttempts = 0;
+        setStatus("navigating");
+      }
+    } else {
+      offCount += 1;
+      offSince ??= fix.timestamp;
+      if (status === "navigating" && offCount >= rs.th.offRouteFixes && fix.timestamp - offSince >= rs.th.offRouteSeconds * 1e3) {
+        setStatus("off_route");
+        emit("offRoute", { distance_m: snap.distance_m, fix });
+      }
+    }
+    const displayAlong_m = Math.max(along_m, maxAlong_m);
+    const at = progressAt(rs.index, displayAlong_m);
+    const rawFlat = rs.index.steps[at.stepIndex];
+    if (!rawFlat) return;
+    const rawNextFlat = rs.index.steps[at.stepIndex + 1];
+    const moving = (fix.speed_mps ?? 0) > MOVING_SPEED_MPS;
+    const bearing = moving && typeof fix.heading === "number" && Number.isFinite(fix.heading) ? fix.heading : segmentBearing2(snap.shapeIndex);
+    const end = rs.index.coords[rs.index.coords.length - 1];
+    const lastLeg = at.legIndex === rs.route.legs.length - 1;
+    const nearEnd = end !== void 0 && lastLeg && haversineM(here, end) <= rs.th.arrive_m && at.remaining_m <= ARRIVE_NEAR_REMAINING_M;
+    const arrivingNow = status === "navigating" && (at.remaining_m <= rs.th.arrive_m || nearEnd);
+    const rawStepChanged = prev === null || prev.stepIndex !== at.stepIndex;
+    const announceProgress = {
+      status,
+      route: rs.route,
+      routeIndex: rs.routeIndex,
+      legIndex: at.legIndex,
+      stepIndex: at.stepIndex,
+      step: rawFlat.step,
+      nextStep: rawNextFlat ? rawNextFlat.step : null,
+      snapped: snap.point,
+      bearing,
+      shapeIndex: snap.shapeIndex,
+      traveled_m: displayAlong_m,
+      remaining_m: at.remaining_m,
+      remaining_s: at.remaining_s,
+      distanceToStep_m: at.distanceToStep_m,
+      offRoute_m: snap.distance_m,
+      fix
+    };
+    const finalIndex = rs.index.steps.length - 1;
+    const finalFlat = rs.index.steps[finalIndex];
+    const effectiveAt = arrivingNow && finalFlat ? {
+      stepIndex: finalIndex,
+      legIndex: finalFlat.legIndex,
+      distanceToStep_m: 0,
+      remaining_m: 0,
+      remaining_s: 0
+    } : at;
+    const flat = arrivingNow && finalFlat ? finalFlat : rawFlat;
+    const nextFlat = arrivingNow ? void 0 : rawNextFlat;
+    const stepChanged = prev === null || prev.stepIndex !== effectiveAt.stepIndex;
+    const legChanged = prev !== null && effectiveAt.legIndex > prev.legIndex;
+    progress = {
+      status,
+      route: rs.route,
+      routeIndex: rs.routeIndex,
+      legIndex: effectiveAt.legIndex,
+      stepIndex: effectiveAt.stepIndex,
+      step: flat.step,
+      nextStep: nextFlat ? nextFlat.step : null,
+      snapped: snap.point,
+      bearing,
+      shapeIndex: snap.shapeIndex,
+      traveled_m: arrivingNow ? rs.index.total_m : displayAlong_m,
+      remaining_m: effectiveAt.remaining_m,
+      remaining_s: effectiveAt.remaining_s,
+      distanceToStep_m: effectiveAt.distanceToStep_m,
+      offRoute_m: snap.distance_m,
+      fix
+    };
+    last = {
+      fix,
+      // Neo cửa sổ chỉ đi theo fix ĐANG ở trên tuyến; fix lệch giữ nguyên neo tốt gần nhất.
+      shapeIndex: onRoute ? snap.shapeIndex : anchorShapeIndex ?? snap.shapeIndex,
+      along_m: arrivingNow ? rs.index.total_m : displayAlong_m,
+      stepIndex: effectiveAt.stepIndex,
+      legIndex: effectiveAt.legIndex
+    };
+    if (status === "navigating") {
+      if (stepChanged && prev !== null) {
+        emit("step", { stepIndex: effectiveAt.stepIndex, step: flat.step });
+      }
+      if (legChanged) {
+        const waypoint = rs.response.waypoints[effectiveAt.legIndex];
+        if (waypoint) emit("waypoint", { legIndex: effectiveAt.legIndex, waypoint });
+      }
+    }
+    emit("progress", progress);
+    if (status === "navigating") {
+      if (skippedViaStep) {
+        const key = `via:${currentLeg}:arrive`;
+        const text = skippedViaStep.step.verbal_pre;
+        if (text && !announced.has(key)) {
+          announced.add(key);
+          const viaStepIndex = rs.index.steps.indexOf(skippedViaStep);
+          emit("announce", { text, kind: "arrive", stepIndex: viaStepIndex, priority: 3 });
+        }
+      }
+      for (const a of planAnnouncements(announceProgress, rs.th, lang, announced, rawStepChanged)) {
+        emit("announce", a);
+      }
+      if (arrivingNow) {
+        setStatus("arrived");
+        progress = { ...progress, status };
+        const waypoint = rs.response.waypoints[rs.response.waypoints.length - 1];
+        if (waypoint) emit("arrive", { waypoint, fix });
+      }
+    } else if (status === "off_route") {
+      maybeAutoReroute(fix, effectiveAt.legIndex);
+    }
+  }
+  return {
+    get status() {
+      return status;
+    },
+    get progress() {
+      return progress;
+    },
+    update,
+    setRoute(response, routeIndex = 0) {
+      rerouteToken += 1;
+      inflight = false;
+      rerouteAttempts = 0;
+      lastRerouteAt = null;
+      applyRoute(response, routeIndex);
+      if (status === "off_route" || status === "rerouting") setStatus("navigating");
+    },
+    async reroute() {
+      if (!provider) throw new Error("createNavigator: kh\xF4ng c\xF3 provider \u0111\u1EC3 t\xEDnh l\u1EA1i");
+      if (status === "arrived" || status === "stopped") return;
+      if (!last) throw new Error("createNavigator: ch\u01B0a c\xF3 v\u1ECB tr\xED \u0111\u1EC3 t\xEDnh l\u1EA1i");
+      await runReroute("manual", last.fix, last.legIndex);
+    },
+    stop() {
+      rerouteToken += 1;
+      inflight = false;
+      setStatus("stopped");
+    },
+    on(event, handler) {
+      listeners[event].add(handler);
+    },
+    off(event, handler) {
+      listeners[event].delete(handler);
+    }
+  };
+}
+
+// src/navigation/route-features.ts
+var EMPTY_ROUTE_FEATURES = {
+  type: "FeatureCollection",
+  features: []
+};
+function decodeRoutes(response) {
+  return response.routes.map((route) => decodePolyline6(route.geometry));
+}
+var line = (kind, index, coordinates) => ({
+  type: "Feature",
+  geometry: { type: "LineString", coordinates },
+  properties: { kind, index }
+});
+function routeFeatures(coords, opts) {
+  const progress = opts.progress ?? null;
+  const features = [];
+  for (const [i, c] of coords.entries()) {
+    if (i !== opts.active) {
+      features.push(line("alt", i, [...c]));
+      continue;
+    }
+    if (progress && progress.shapeIndex < c.length - 1) {
+      features.push(
+        line("traveled", i, [...c.slice(0, progress.shapeIndex + 1), progress.snapped]),
+        line("active", i, [progress.snapped, ...c.slice(progress.shapeIndex + 1)])
+      );
+    } else {
+      features.push(line("active", i, [...c]));
+    }
+  }
+  if (opts.puck && progress) {
+    features.push({
+      type: "Feature",
+      geometry: { type: "Point", coordinates: progress.snapped },
+      properties: { kind: "puck", bearing: progress.bearing ?? 0 }
+    });
+  }
+  return { type: "FeatureCollection", features };
+}
 export {
   ATTRIBUTION_LINKS,
   DEFAULT_POI_SOURCES,
+  EMPTY_ROUTE_FEATURES,
+  FIRST_SYMBOL_LAYER_ID,
+  MANEUVER_KINDS,
   MapsLibVNError,
   NAME_FILLERS,
+  NAVIGATION_THRESHOLDS,
   POI_LAYER_ID,
   POI_SOURCES,
   POI_SOURCE_PROFILES,
+  SIMULATE_DEFAULT_SPEED_MPS,
   TOPONYM_ALIAS,
+  VALHALLA_MANEUVER_KIND,
   adminAliasKeys,
+  angleDiffDeg,
   applyBrandAlias,
   applyToponymAlias,
   attributionHtml,
   attributionText,
+  bearingDeg,
+  buildRouteIndex,
+  composeApproach,
   createClient,
+  createNavigator,
+  cumulativeDistances,
+  decodePolyline6,
+  decodeRoutes,
+  encodePolyline6,
   expandAbbrev,
   filterNameAlt,
   foldTelex,
+  formatDistance,
+  formatDistanceShort,
+  haversineM,
   hidePoiLayer,
   isNameLabelLayer,
   isPoiStyleLayer,
   localizeStyle,
   looksLikeTelex,
+  lowerFirst,
+  maneuverKindFromValhalla,
+  mulberry32,
   nameCore,
   nameExpression,
   normalizePoiSources,
   normalizeVi,
   parseAddress,
   parsePoiSourcesCsv,
+  planAnnouncements,
   poiSourceClause,
   poiSourcesKey,
   profileForSources,
+  progressAt,
+  projectOnSegment,
+  roundForSpeech,
+  routeFeatures,
   searchKeys,
+  simulateFixes,
+  snapToRoute,
+  stepAt,
   stripDiacritics,
   viKey
 };