@mapslibvn/react-native 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  __publicField
+} from "./chunk-PKBMQBKP.js";
 
 // src/map.tsx
 import {
@@ -70,6 +70,7 @@ function normalizePoiSources(list) {
 function poiSourcesKey(sources) {
   return (normalizePoiSources(sources) ?? []).join(",");
 }
+var latLng = ([lat, lng]) => `${lat},${lng}`;
 function createClient(options) {
   const baseUrl = options.baseUrl.replace(/\/+$/, "");
   const poiSources = normalizePoiSources(options.poiSources ?? DEFAULT_POI_SOURCES);
@@ -152,6 +153,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)
   };
@@ -280,6 +290,10 @@ var RE_STREET_LIKE = new RegExp(
   String.raw`^${PREFIX}${NUM_LEAD}(?:/|\s|$)|\b${ALLEY_KW}\s*\d|^(?:duong|d\.|pho)\s`
 );
 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";
@@ -426,12 +440,701 @@ var compile = (rules) => rules.map(([pattern, replacement]) => ({ re: new RegExp
 var WORD_START = compile(RULES2.wordStart);
 var WORD_END = compile(RULES2.wordEnd);
 var ANYWHERE = compile(RULES2.anywhere);
+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;
+}
+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
+  }
+};
+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;
+}
+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)
+  };
+}
+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;
+}
+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;
+}
+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;
+}
+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 ?? (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);
+    }
+  };
+}
+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 };
+}
 
 // src/map.tsx
-import { useContext, useEffect as useEffect2, useMemo, useRef } from "react";
+import { useContext as useContext2, useEffect as useEffect2, useMemo, useRef } from "react";
 import {
-  StyleSheet as StyleSheet2,
-  View
+  AppState,
+  StyleSheet as StyleSheet3,
+  View as View2
 } from "react-native";
 
 // src/attribution.tsx
@@ -469,6 +1172,576 @@ var styles = StyleSheet.create({
 import { createContext } from "react";
 var MapContext = createContext(null);
 
+// src/navigation/map-binding.ts
+var FOLLOW_ZOOM = {
+  walk: 17,
+  motorbike: 16.5,
+  car: 15.5
+};
+var FOLLOW_PITCH = 45;
+var SESSION_EVENTS = [
+  "status",
+  "progress",
+  "step",
+  "waypoint",
+  "offRoute",
+  "reroute",
+  "rerouteFailed",
+  "announce",
+  "arrive",
+  "route",
+  "positionError",
+  "voiceUnavailable",
+  "backgroundUnavailable",
+  "end"
+];
+function createMapBinding(deps) {
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, e) => {
+    for (const fn of listeners.get(event) ?? []) fn(e);
+  };
+  let explicit = null;
+  let fallback = null;
+  let attached = null;
+  let detachFns = [];
+  let follow = {
+    pitch: FOLLOW_PITCH
+  };
+  let following = true;
+  let lastFixTs = null;
+  const camera = (p) => {
+    if (!follow || !following || deps.appState.currentState !== "active") return;
+    const dt = lastFixTs === null ? 500 : p.fix.timestamp - lastFixTs;
+    lastFixTs = p.fix.timestamp;
+    deps.camera.current?.easeTo({
+      center: p.snapped,
+      bearing: p.bearing,
+      zoom: follow.zoom ?? FOLLOW_ZOOM[p.route.mode],
+      pitch: follow.pitch,
+      duration: Math.max(0, Math.min(1e3, dt)),
+      ...follow.padding ? { padding: follow.padding } : {}
+    });
+  };
+  const paint = (p) => {
+    deps.store.setProgress({ shapeIndex: p.shapeIndex, snapped: p.snapped, bearing: p.bearing });
+    camera(p);
+  };
+  const detach = () => {
+    for (const fn of detachFns) fn();
+    detachFns = [];
+    attached = null;
+    lastFixTs = null;
+    deps.store.clear();
+  };
+  const attachTo = (session) => {
+    if (attached === session) return;
+    detach();
+    attached = session;
+    const on = (k, fn) => {
+      session.on(k, fn);
+      detachFns.push(() => session.off(k, fn));
+    };
+    for (const name of SESSION_EVENTS) {
+      on(name, (e) => {
+        if (name === "progress") paint(e);
+        else if (name === "route") {
+          const r = e;
+          deps.store.show(r.response, { active: r.routeIndex });
+        }
+        emit(name, e);
+      });
+    }
+    if (session.response) deps.store.show(session.response, { active: session.routeIndex });
+    const p = session.state;
+    if (p) paint(p);
+  };
+  const current = () => explicit ?? fallback;
+  const resolve = () => {
+    if (explicit) return explicit;
+    if (!fallback) fallback = deps.createDefaultSession();
+    if (attached !== fallback) attachTo(fallback);
+    return fallback;
+  };
+  const appSub = deps.appState.addEventListener("change", (s) => {
+    if (s !== "active") return;
+    const p = attached?.state;
+    if (p) camera(p);
+  });
+  const api = {
+    get session() {
+      return resolve();
+    },
+    get following() {
+      return following;
+    },
+    recenter() {
+      if (!follow) return;
+      following = true;
+      emit("followChange", true);
+      const p = attached?.state;
+      if (p) camera(p);
+    },
+    start: (o) => resolve().start(o),
+    stop: () => current()?.stop() ?? Promise.resolve(),
+    reroute: () => current()?.reroute() ?? Promise.reject(new Error("Phi\xEAn d\u1EABn \u0111\u01B0\u1EDDng ch\u01B0a start()")),
+    get state() {
+      return current()?.state ?? null;
+    },
+    get status() {
+      return current()?.status ?? "idle";
+    },
+    on(event, handler) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(handler);
+    },
+    off(event, handler) {
+      listeners.get(event)?.delete(handler);
+    }
+  };
+  return {
+    api,
+    attach(session) {
+      explicit = session;
+      if (session) attachTo(session);
+      else detach();
+    },
+    setFollow(opt) {
+      if (opt === false) {
+        follow = null;
+        following = false;
+        return;
+      }
+      const o = typeof opt === "object" ? opt : {};
+      follow = {
+        pitch: o.pitch ?? FOLLOW_PITCH,
+        ...o.zoom !== void 0 ? { zoom: o.zoom } : {},
+        ...o.padding ? { padding: o.padding } : {}
+      };
+      following = true;
+    },
+    userGesture() {
+      if (!following) return;
+      following = false;
+      emit("followChange", false);
+    },
+    dispose() {
+      detach();
+      appSub.remove();
+      listeners.clear();
+    }
+  };
+}
+
+// src/navigation/route-layers.tsx
+import {
+  GeoJSONSource,
+  Images,
+  Layer
+} from "@maplibre/maplibre-react-native";
+import { useSyncExternalStore } from "react";
+
+// src/marker.tsx
+import { Marker as NativeMarker } from "@maplibre/maplibre-react-native";
+import { useContext } from "react";
+import { StyleSheet as StyleSheet2, View } from "react-native";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var DEFAULT_MARKER_COLOR = "#3FB1CE";
+function Marker({
+  lng,
+  lat,
+  color = DEFAULT_MARKER_COLOR,
+  anchor = "center",
+  onPress,
+  children,
+  testID
+}) {
+  if (!useContext(MapContext)) throw new Error("useMap ph\u1EA3i \u0111\u01B0\u1EE3c g\u1ECDi b\xEAn trong <MapsLibVNMap>");
+  const pin = children ?? /* @__PURE__ */ jsx2(View, { style: [styles2.pin, { backgroundColor: color }], testID: "mapslibvn-marker-pin" });
+  return /* @__PURE__ */ jsx2(
+    NativeMarker,
+    {
+      lngLat: [lng, lat],
+      anchor,
+      ...onPress ? { onPress: () => onPress() } : {},
+      ...testID ? { testID } : {},
+      children: pin
+    }
+  );
+}
+var styles2 = StyleSheet2.create({
+  pin: {
+    width: 22,
+    height: 22,
+    borderRadius: 11,
+    borderWidth: 3,
+    borderColor: "#ffffff"
+  }
+});
+
+// src/navigation/puck-image.ts
+var PUCK_IMAGE_KEY = "mapslibvn-puck";
+var PUCK_PNG_DATA_URI = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEIAAABCCAYAAADjVADoAAADUUlEQVR42u2bv4rVQBTG9xH2EbbwAS6+gPcF7BdsgpWNsJXbBrEUAjaWwcZqLWy0UMhi48JiJStWjqCNFoqghdWREzJxcnLyZ86dyZ1kcuBAyN1NZr58c+Z3D7kHB2ussUaIAQBbzFUIgAIzdhE28D82MQuRG0LksYpwBO04it0Ncbqiww3xuQIAMj3ri6tvZRqRxSLCIQD81LO+9/htmUbgZ4cxCJHqGX/9/huuHT8tE4+NSKNyw4Mn72oh8DgaV5hu+PXnL1y/fVYLgcd4LgpXAICq98kXH2sRdOI5I9RSRUjMWd64+7wlBJ4jkSzaDc/OP7VE0ImfLdYV1A237r/uFAI/W6wrTDcgPHWJoJMAllqKCFtzVghPQ0IQwIJFNG6qxksLoIaSAFaxKDeYADWUBLDm7QrTDRSghpIBrGKuImwajQYGoIaSANY823m08cIB1FAygJXPTYRG46UPoIaSANa8GjfUDX0ANZQMYOWzdMMYgLIErHm4wmzDjQUoAWBloYvQaLzYAJQlYIXduDEbL7YAJQCsdBZusAUoAWCF6QrqBglACQArDVEItStACQBLhSZC4gqgBICVBOuGXQBKAFgqSDe4ACgBYCXBucEFQAkAS+1bhEbjxSVAWQLWfhs3ZuPFNUAJAKsIwg2uAUoAWPtxBXWDD4ASAFYxtQgbOgIfACUArGnbebTxIgWom6cv6zdm8NgRYOVTidB6/8kWoPBJMhMoz9k6iwGsaRo31A02AIUF7tHZe67INYou/o1N4WUAK5/cDWMBCre7PgE4QcZuxwxg+XUFbcONAag7D99w8FM/Of1Sesd7l+X/4jUEgJX5EqHReBkCKFy7jGV1QyXjnljluIzeRy/BvlrEAJafxg1tvHQBFBa7V5dfOAHwO8nJmMFVop/Q7zEYeG2uoHYAVurdDRSgcCAM4EAFXskO904ovOn70wfB3N+tK6gbTIDq2Qlyl8jL1RG6w3QAVupSCMUBFFZrps2e+azYXB3BMejdi+ET5erGCb0yPoUPn3+I1r/j5dqoIzgmHBsTiXM3uFz/jrtkRc84lXM3+Fj/PuuIE1cQN3hf/z7riNgVRuNl8vXvsY5sJRdJl/SyZ7XMl/3zhzXWWGONNSaKf5vNEuTO/lstAAAAAElFTkSuQmCC";
+
+// src/navigation/route-layers.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var ROUTE_SOURCE_ID = "mapslibvn-route";
+var ROUTE_LAYER_IDS = {
+  alt: "mapslibvn-route-alt",
+  casing: "mapslibvn-route-casing",
+  line: "mapslibvn-route-line",
+  traveled: "mapslibvn-route-traveled",
+  puck: "mapslibvn-route-puck"
+};
+var ROUTE_COLOR = "#2458a6";
+var ALT_ROUTE_COLOR = "#9ca8ba";
+var DESTINATION_COLOR = "#d92d20";
+var kindIs = (kind) => ["==", ["get", "kind"], kind];
+var ROUND = {
+  "line-join": "round",
+  "line-cap": "round"
+};
+var PUCK_LAYOUT = {
+  "icon-image": PUCK_IMAGE_KEY,
+  "icon-rotate": ["get", "bearing"],
+  "icon-rotation-alignment": "map",
+  "icon-pitch-alignment": "map",
+  "icon-allow-overlap": true,
+  "icon-ignore-placement": true,
+  "icon-size": 0.5
+};
+function RouteLayers({ store, routeStyle, beforeId, onRouteClick }) {
+  const snap = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  if (!snap.response) return null;
+  const color = routeStyle?.color ?? ROUTE_COLOR;
+  const altColor = routeStyle?.altColor ?? ALT_ROUTE_COLOR;
+  const casingColor = routeStyle?.casingColor ?? "#ffffff";
+  const traveledOpacity = routeStyle?.traveledOpacity ?? 0.35;
+  const before = beforeId ? { beforeId } : {};
+  const onPress = (e) => {
+    const alt = e.nativeEvent.features.find((f) => f.properties?.kind === "alt");
+    const index = alt?.properties?.index;
+    if (typeof index === "number") onRouteClick?.(index);
+  };
+  const waypoints = snap.response.waypoints;
+  const last = waypoints.length - 1;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3(Images, { images: { [PUCK_IMAGE_KEY]: { source: { uri: PUCK_PNG_DATA_URI } } } }),
+    /* @__PURE__ */ jsxs(
+      GeoJSONSource,
+      {
+        id: ROUTE_SOURCE_ID,
+        data: snap.features,
+        onPress,
+        children: [
+          /* @__PURE__ */ jsx3(
+            Layer,
+            {
+              type: "line",
+              id: ROUTE_LAYER_IDS.alt,
+              source: ROUTE_SOURCE_ID,
+              filter: kindIs("alt"),
+              layout: ROUND,
+              paint: { "line-color": altColor, "line-width": 5 },
+              ...before
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            Layer,
+            {
+              type: "line",
+              id: ROUTE_LAYER_IDS.casing,
+              source: ROUTE_SOURCE_ID,
+              filter: kindIs("active"),
+              layout: ROUND,
+              paint: { "line-color": casingColor, "line-width": 9 },
+              ...before
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            Layer,
+            {
+              type: "line",
+              id: ROUTE_LAYER_IDS.line,
+              source: ROUTE_SOURCE_ID,
+              filter: kindIs("active"),
+              layout: ROUND,
+              paint: { "line-color": color, "line-width": 6 },
+              ...before
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            Layer,
+            {
+              type: "line",
+              id: ROUTE_LAYER_IDS.traveled,
+              source: ROUTE_SOURCE_ID,
+              filter: kindIs("traveled"),
+              layout: ROUND,
+              paint: { "line-color": color, "line-width": 6, "line-opacity": traveledOpacity },
+              ...before
+            }
+          ),
+          snap.puck ? /* @__PURE__ */ jsx3(
+            Layer,
+            {
+              type: "symbol",
+              id: ROUTE_LAYER_IDS.puck,
+              source: ROUTE_SOURCE_ID,
+              filter: kindIs("puck"),
+              layout: PUCK_LAYOUT
+            }
+          ) : null
+        ]
+      }
+    ),
+    waypoints.map(
+      (w, i) => i === 0 ? null : /* @__PURE__ */ jsx3(
+        Marker,
+        {
+          lng: w.snapped[0],
+          lat: w.snapped[1],
+          color: i === last ? DESTINATION_COLOR : ALT_ROUTE_COLOR,
+          testID: "mapslibvn-route-marker"
+        },
+        `${i}-${w.snapped[0]}-${w.snapped[1]}`
+      )
+    )
+  ] });
+}
+
+// src/navigation/routes-store.ts
+function createRoutesStore() {
+  let coords = [];
+  let snapshot = {
+    response: null,
+    active: 0,
+    progress: null,
+    puck: true,
+    features: EMPTY_ROUTE_FEATURES
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const set = (patch) => {
+    const next = { ...snapshot, ...patch };
+    next.features = next.response ? routeFeatures(coords, { active: next.active, progress: next.progress, puck: next.puck }) : EMPTY_ROUTE_FEATURES;
+    snapshot = next;
+    for (const fn of listeners) fn();
+  };
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(onChange) {
+      listeners.add(onChange);
+      return () => {
+        listeners.delete(onChange);
+      };
+    },
+    show(response, opts = {}) {
+      coords = decodeRoutes(response);
+      set({ response, active: opts.active ?? 0, progress: null });
+    },
+    setActive(index) {
+      set({ active: index, progress: null });
+    },
+    setProgress(cut) {
+      set({ progress: cut });
+    },
+    setPuck(on) {
+      if (on !== snapshot.puck) set({ puck: on });
+    },
+    clear() {
+      coords = [];
+      set({ response: null, progress: null });
+    }
+  };
+}
+
+// src/navigation/session.ts
+var MISSING_SOURCE_MESSAGE = "Phi\xEAn d\u1EABn \u0111\u01B0\u1EDDng thi\u1EBFu ngu\u1ED3n v\u1ECB tr\xED: truy\u1EC1n source (v\xED d\u1EE5 expoLocationSource() t\u1EEB @mapslibvn/react-native/expo)";
+var FORWARDED = [
+  "progress",
+  "step",
+  "waypoint",
+  "offRoute",
+  "reroute",
+  "rerouteFailed",
+  "announce",
+  "arrive"
+];
+function createNavigationSession(opts) {
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, e) => {
+    for (const fn of listeners.get(event) ?? []) fn(e);
+  };
+  let nav = null;
+  let unsubscribe = null;
+  let running = false;
+  let ended = false;
+  let startToken = 0;
+  let response = null;
+  let routeIndex = 0;
+  let voiceOn = false;
+  let keepOn = false;
+  let audioOn = false;
+  const currentStatus = () => {
+    if (!nav) return "idle";
+    return nav.status === "idle" ? "navigating" : nav.status;
+  };
+  const releaseSource = () => {
+    unsubscribe?.();
+    unsubscribe = null;
+  };
+  const releaseDevice = async () => {
+    if (keepOn) {
+      keepOn = false;
+      try {
+        await opts.keepAwake?.deactivate();
+      } catch {
+      }
+    }
+    if (audioOn) {
+      audioOn = false;
+      try {
+        await opts.audio?.deactivate();
+      } catch {
+      }
+    }
+  };
+  async function stop() {
+    if (!running) return;
+    running = false;
+    startToken += 1;
+    const previous = currentStatus();
+    releaseSource();
+    if (voiceOn) opts.speech?.cancel();
+    voiceOn = false;
+    const engine = nav;
+    nav = null;
+    engine?.stop();
+    await releaseDevice();
+    emit("status", { status: "idle", previous });
+    if (!ended) emit("end", { reason: "stopped" });
+    ended = false;
+  }
+  async function start(o) {
+    if (running) await stop();
+    const source = opts.source;
+    if (!source) throw new Error(MISSING_SOURCE_MESSAGE);
+    running = true;
+    ended = false;
+    startToken += 1;
+    const token = startToken;
+    response = o.response;
+    routeIndex = o.routeIndex ?? 0;
+    const lang = o.lang ?? "vi";
+    const navOptions = {
+      response: o.response,
+      routeIndex,
+      provider: opts.provider,
+      reroute: o.reroute ?? "auto",
+      lang
+    };
+    if (o.thresholds) navOptions.thresholds = o.thresholds;
+    const engine = createNavigator(navOptions);
+    const mode = o.response.routes[routeIndex]?.mode ?? "motorbike";
+    voiceOn = o.voice !== false && Boolean(opts.speech);
+    if (voiceOn && opts.speech) {
+      if (typeof o.voice === "object") opts.speech.setOptions?.(o.voice);
+      if (opts.audio) {
+        audioOn = true;
+        try {
+          await opts.audio.activate();
+        } catch {
+        }
+      }
+      let available = true;
+      try {
+        available = await opts.speech.available(lang);
+      } catch {
+      }
+      if (token !== startToken) return;
+      if (!available) emit("voiceUnavailable", void 0);
+    }
+    keepOn = (o.keepAwake ?? true) && Boolean(opts.keepAwake);
+    if (keepOn) {
+      try {
+        await opts.keepAwake?.activate();
+      } catch {
+      }
+    }
+    if (token !== startToken) return;
+    nav = engine;
+    for (const name of FORWARDED) {
+      engine.on(name, (e) => emit(name, e));
+    }
+    engine.on("status", (e) => {
+      if (e.status === "stopped") return;
+      if (e.status === "navigating" && e.previous === "idle") return;
+      emit("status", e);
+    });
+    engine.on("announce", (a) => {
+      if (voiceOn) opts.speech?.speak(a.text, a.priority, lang);
+    });
+    engine.on("reroute", (e) => {
+      response = e.response;
+      routeIndex = 0;
+      emit("route", { response: e.response, routeIndex: 0 });
+    });
+    engine.on("arrive", () => {
+      ended = true;
+      releaseSource();
+      void releaseDevice();
+      emit("end", { reason: "arrived" });
+    });
+    emit("route", { response: o.response, routeIndex });
+    emit("status", { status: "navigating", previous: "idle" });
+    source.setMode?.(mode);
+    source.onBackgroundUnavailable?.((e) => emit("backgroundUnavailable", e));
+    unsubscribe = source.subscribe(
+      (fix) => engine.update(fix),
+      (error) => emit("positionError", error)
+    );
+  }
+  return {
+    start,
+    stop,
+    reroute() {
+      return nav ? nav.reroute() : Promise.reject(new Error("Phi\xEAn d\u1EABn \u0111\u01B0\u1EDDng ch\u01B0a start()"));
+    },
+    setRoute(next, index = 0) {
+      response = next;
+      routeIndex = index;
+      nav?.setRoute(next, index);
+      emit("route", { response: next, routeIndex: index });
+    },
+    get status() {
+      return currentStatus();
+    },
+    get state() {
+      return nav?.progress ?? null;
+    },
+    get response() {
+      return response;
+    },
+    get routeIndex() {
+      return routeIndex;
+    },
+    on(event, handler) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(handler);
+    },
+    off(event, handler) {
+      listeners.get(event)?.delete(handler);
+    }
+  };
+}
+
 // src/to-poi-feature.ts
 function toPoiFeature(feature) {
   if (!feature || feature.geometry.type !== "Point") return null;
@@ -538,7 +1811,7 @@ function useResolvedStyle(places, options, doFetch = globalThis.fetch) {
 }
 
 // src/map.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
 var DEFAULT_CENTER = [106.7, 10.776];
 var DEFAULT_ZOOM = 12;
 function MapsLibVNMap({
@@ -553,6 +1826,13 @@ function MapsLibVNMap({
   compactAttribution = false,
   bundleId,
   containerStyle,
+  navigation,
+  sessionOptions,
+  follow = true,
+  puck = true,
+  routeStyle,
+  routeBeforeLayerId,
+  onRouteClick,
   onLoad,
   onPoiClick,
   onError,
@@ -571,8 +1851,31 @@ function MapsLibVNMap({
   );
   const native = useRef(null);
   const camera = useRef(null);
-  const handlers = useRef({ onLoad, onPoiClick, onError });
-  handlers.current = { onLoad, onPoiClick, onError };
+  const handlers = useRef({ onLoad, onPoiClick, onError, onRouteClick });
+  handlers.current = { onLoad, onPoiClick, onError, onRouteClick };
+  const sessionOptionsRef = useRef(sessionOptions);
+  sessionOptionsRef.current = sessionOptions;
+  const store = useMemo(() => createRoutesStore(), []);
+  const binding = useMemo(
+    () => createMapBinding({
+      camera,
+      store,
+      appState: AppState,
+      createDefaultSession: () => createNavigationSession({ provider: places, ...sessionOptionsRef.current })
+    }),
+    [places, store]
+  );
+  useEffect2(() => () => binding.dispose(), [binding]);
+  useEffect2(() => {
+    binding.attach(navigation ?? null);
+  }, [binding, navigation]);
+  const followKey = JSON.stringify(follow);
+  useEffect2(() => {
+    binding.setFollow(JSON.parse(followKey));
+  }, [binding, followKey]);
+  useEffect2(() => {
+    store.setPuck(puck);
+  }, [store, puck]);
   const handle = useMemo(
     () => ({
       native,
@@ -590,9 +1893,15 @@ function MapsLibVNMap({
         const b = await native.current?.getBounds();
         if (!b) throw new Error("B\u1EA3n \u0111\u1ED3 ch\u01B0a s\u1EB5n s\xE0ng");
         return b;
-      }
+      },
+      routes: {
+        show: (response, opts) => store.show(response, opts ?? {}),
+        setActive: (index) => store.setActive(index),
+        clear: () => store.clear()
+      },
+      navigation: binding.api
     }),
-    [places]
+    [places, store, binding]
   );
   const resolved = useResolvedStyle(places, { style, lang, poiLayer });
   useEffect2(() => {
@@ -608,17 +1917,22 @@ function MapsLibVNMap({
     const poi = toPoiFeature(features?.[0]);
     if (poi) handlers.current.onPoiClick?.(poi);
   };
-  return /* @__PURE__ */ jsxs(View, { style: [styles2.container, containerStyle], ...testID ? { testID } : {}, children: [
-    resolved.status === "ready" ? /* @__PURE__ */ jsxs(
+  const onRegionWillChange = (e) => {
+    if (e.nativeEvent.userInteraction) binding.userGesture();
+  };
+  const beforeId = routeBeforeLayerId === void 0 ? isTheme(style) ? FIRST_SYMBOL_LAYER_ID[style] : null : routeBeforeLayerId;
+  return /* @__PURE__ */ jsxs2(View2, { style: [styles3.container, containerStyle], ...testID ? { testID } : {}, children: [
+    resolved.status === "ready" ? /* @__PURE__ */ jsxs2(
       NativeMap,
       {
         ref: native,
-        style: styles2.map,
+        style: styles3.map,
         mapStyle: resolved.mapStyle,
         attribution: true,
         attributionPosition: { bottom: 8, right: 8 },
         logo: false,
         onPress,
+        onRegionWillChange,
         onDidFinishLoadingStyle: () => {
           if (loadedFor.current === mapKey) return;
           loadedFor.current = mapKey;
@@ -626,13 +1940,24 @@ function MapsLibVNMap({
         },
         onDidFailLoadingMap: () => handlers.current.onError?.(new Error("Kh\xF4ng t\u1EA3i \u0111\u01B0\u1EE3c b\u1EA3n \u0111\u1ED3")),
         children: [
-          /* @__PURE__ */ jsx2(Camera, { ref: camera, initialViewState: { center, zoom } }),
-          /* @__PURE__ */ jsx2(MapContext.Provider, { value: handle, children })
+          /* @__PURE__ */ jsx4(Camera, { ref: camera, initialViewState: { center, zoom } }),
+          /* @__PURE__ */ jsxs2(MapContext.Provider, { value: handle, children: [
+            /* @__PURE__ */ jsx4(
+              RouteLayers,
+              {
+                store,
+                routeStyle,
+                beforeId,
+                onRouteClick: (index) => handlers.current.onRouteClick?.(index)
+              }
+            ),
+            children
+          ] })
         ]
       },
       mapKey
     ) : null,
-    /* @__PURE__ */ jsx2(
+    /* @__PURE__ */ jsx4(
       Attribution,
       {
         compact: compactAttribution,
@@ -644,56 +1969,19 @@ function MapsLibVNMap({
   ] });
 }
 function useMap() {
-  const map = useContext(MapContext);
+  const map = useContext2(MapContext);
   if (!map) throw new Error("useMap ph\u1EA3i \u0111\u01B0\u1EE3c g\u1ECDi b\xEAn trong <MapsLibVNMap>");
   return map;
 }
-var styles2 = StyleSheet2.create({
+var styles3 = StyleSheet3.create({
   container: { flex: 1, position: "relative" },
   map: { flex: 1 }
 });
 
-// src/marker.tsx
-import { Marker as NativeMarker } from "@maplibre/maplibre-react-native";
-import { StyleSheet as StyleSheet3, View as View2 } from "react-native";
-import { jsx as jsx3 } from "react/jsx-runtime";
-var DEFAULT_MARKER_COLOR = "#3FB1CE";
-function Marker({
-  lng,
-  lat,
-  color = DEFAULT_MARKER_COLOR,
-  anchor = "center",
-  onPress,
-  children,
-  testID
-}) {
-  useMap();
-  const pin = children ?? /* @__PURE__ */ jsx3(View2, { style: [styles3.pin, { backgroundColor: color }], testID: "mapslibvn-marker-pin" });
-  return /* @__PURE__ */ jsx3(
-    NativeMarker,
-    {
-      lngLat: [lng, lat],
-      anchor,
-      ...onPress ? { onPress: () => onPress() } : {},
-      ...testID ? { testID } : {},
-      children: pin
-    }
-  );
-}
-var styles3 = StyleSheet3.create({
-  pin: {
-    width: 22,
-    height: 22,
-    borderRadius: 11,
-    borderWidth: 3,
-    borderColor: "#ffffff"
-  }
-});
-
 // src/use-places.ts
-import { useContext as useContext2, useEffect as useEffect3, useState as useState2 } from "react";
+import { useContext as useContext3, useEffect as useEffect3, useState as useState2 } from "react";
 function usePlaces(query, options = {}) {
-  const mapClient = useContext2(MapContext)?.places ?? null;
+  const mapClient = useContext3(MapContext)?.places ?? null;
   const client = options.client ?? mapClient;
   const [items, setItems] = useState2([]);
   const [loading, setLoading] = useState2(false);
@@ -730,13 +2018,125 @@ function usePlaces(query, options = {}) {
   }, [client, query, nearKey, options.limit, options.debounceMs]);
   return { items, loading, error };
 }
+
+// src/use-navigation.ts
+import { useCallback, useContext as useContext4, useSyncExternalStore as useSyncExternalStore2 } from "react";
+var noop = () => {
+};
+function useNavigation(session) {
+  const map = useContext4(MapContext);
+  const binding = session ? null : map?.navigation ?? null;
+  const target = session ?? binding;
+  if (!target) {
+    throw new Error("useNavigation ph\u1EA3i \u0111\u01B0\u1EE3c g\u1ECDi b\xEAn trong <MapsLibVNMap> ho\u1EB7c truy\u1EC1n session");
+  }
+  const subscribeStatus = useCallback(
+    (onChange) => {
+      target.on("status", onChange);
+      return () => target.off("status", onChange);
+    },
+    [target]
+  );
+  const subscribeProgress = useCallback(
+    (onChange) => {
+      target.on("progress", onChange);
+      return () => target.off("progress", onChange);
+    },
+    [target]
+  );
+  const subscribeFollow = useCallback(
+    (onChange) => {
+      if (!binding) return noop;
+      binding.on("followChange", onChange);
+      return () => binding.off("followChange", onChange);
+    },
+    [binding]
+  );
+  const status = useSyncExternalStore2(
+    subscribeStatus,
+    () => target.status,
+    () => target.status
+  );
+  const progress = useSyncExternalStore2(
+    subscribeProgress,
+    () => target.state,
+    () => target.state
+  );
+  const following = useSyncExternalStore2(
+    subscribeFollow,
+    () => binding?.following ?? false,
+    () => binding?.following ?? false
+  );
+  return {
+    status,
+    progress,
+    following,
+    start: (opts) => target.start(opts),
+    stop: () => target.stop(),
+    reroute: () => target.reroute(),
+    recenter: () => binding?.recenter()
+  };
+}
+
+// src/navigation/playback-source.ts
+function playbackSource(fixes, options = {}) {
+  const rate = options.rate ?? 1;
+  return {
+    subscribe(onFix) {
+      let stopped = false;
+      let timer = null;
+      let i = 0;
+      const emitNext = () => {
+        if (stopped) return;
+        const fix = fixes[i];
+        if (!fix) return;
+        onFix(fix);
+        i += 1;
+        const next = fixes[i];
+        if (!next) return;
+        timer = setTimeout(emitNext, Math.max(0, (next.timestamp - fix.timestamp) / rate));
+      };
+      timer = setTimeout(
+        rate <= 0 ? () => {
+          for (const f of fixes) {
+            if (stopped) break;
+            onFix(f);
+          }
+        } : emitNext,
+        0
+      );
+      return () => {
+        stopped = true;
+        if (timer !== null) clearTimeout(timer);
+      };
+    }
+  };
+}
 export {
+  ALT_ROUTE_COLOR,
   COMPACT_ATTRIBUTION,
   DEFAULT_CENTER,
   DEFAULT_MARKER_COLOR,
   DEFAULT_ZOOM,
+  DESTINATION_COLOR,
+  FOLLOW_PITCH,
+  FOLLOW_ZOOM,
+  MISSING_SOURCE_MESSAGE,
   MapsLibVNMap,
   Marker,
+  NAVIGATION_THRESHOLDS,
+  ROUTE_COLOR,
+  ROUTE_LAYER_IDS,
+  ROUTE_SOURCE_ID,
+  createClient,
+  createNavigationSession,
+  createNavigator,
+  decodePolyline6,
+  formatDistance,
+  formatDistanceShort,
+  playbackSource,
+  simulateFixes,
   useMap,
+  useNavigation,
   usePlaces
 };