diff --git a/.changeset/route-stop-network-detours.md b/.changeset/route-stop-network-detours.md
new file mode 100644
index 000000000..bfdead7cc
--- /dev/null
+++ b/.changeset/route-stop-network-detours.md
@@ -0,0 +1,7 @@
+---
+"@openmapx/core": minor
+"@openmapx/i18n": patch
+---
+
+Add bounded remaining-itinerary network detour evaluation and ordered stop insertion,
+explicit entrance fallback, confidence labels, and cancellable provider-pinned requests.
diff --git a/apps/web/src/components/navigation/RouteSearchControl.test.tsx b/apps/web/src/components/navigation/RouteSearchControl.test.tsx
new file mode 100644
index 000000000..bac19739f
--- /dev/null
+++ b/apps/web/src/components/navigation/RouteSearchControl.test.tsx
@@ -0,0 +1,153 @@
+// @vitest-environment jsdom
+
+import { type AlongRoutePoi, type CategoryPlace, useNavigationStore } from "@openmapx/core";
+import en from "@openmapx/i18n/locales/en.json";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { NextIntlClientProvider } from "next-intl";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const fixture = vi.hoisted(() => ({
+  results: [] as AlongRoutePoi<CategoryPlace>[],
+  addStop: vi.fn(),
+  cancel: vi.fn(),
+}));
+vi.mock("@/lib/navigation/useRouteSearch", () => ({
+  routeSearchQueryFor: (value: unknown) => value,
+  useRouteSearch: () => ({
+    results: fixture.results,
+    isLoading: false,
+    addStop: fixture.addStop,
+    cancelAddStop: fixture.cancel,
+  }),
+}));
+vi.mock("@/integration-api/map/MapContext", () => ({ useMapOptional: () => null }));
+vi.mock("@openmapx/core", async (original) => ({
+  ...(await original<typeof import("@openmapx/core")>()),
+  useBrandSuggest: () => ({ data: undefined }),
+}));
+vi.mock("./RouteSearchResultsLayer", () => ({
+  RouteSearchResultsLayer: ({
+    results,
+    onSelect,
+  }: {
+    results: AlongRoutePoi<CategoryPlace>[];
+    onSelect: (poi: AlongRoutePoi<CategoryPlace>) => void;
+  }) => (
+    <button type="button" onClick={() => onSelect(results[0])}>
+      Select stop
+    </button>
+  ),
+}));
+
+import { useRouteSearchStore } from "@/lib/navigation/routeSearchStore";
+import { RouteSearchControl } from "./RouteSearchControl";
+
+function view() {
+  return (
+    <NextIntlClientProvider locale="en" messages={en}>
+      <RouteSearchControl />
+    </NextIntlClientProvider>
+  );
+}
+const poi = () =>
+  ({
+    place: { id: "stop", name: "River services", coordinates: [0.001, 0.001] },
+    alongMeters: 100,
+    deviationMeters: 20,
+    detourSeconds: 3,
+    detourMeters: 40,
+  }) as AlongRoutePoi<CategoryPlace>;
+beforeEach(() => {
+  fixture.results = [poi()];
+  fixture.cancel.mockReset();
+  fixture.addStop.mockReset();
+  useRouteSearchStore.getState().reset();
+  useRouteSearchStore.getState().setCategoryKey("preset:amenity/fuel");
+});
+describe("route stop confidence", () => {
+  it("exits search after its successful add changes the active route", async () => {
+    let finish!: (value: boolean) => void;
+    fixture.addStop.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    render(view());
+    fireEvent.click(screen.getByText("Select stop"));
+    fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    act(() =>
+      useNavigationStore.setState({
+        route: {
+          geometry: [
+            [0, 0],
+            [0.002, 0],
+          ],
+        } as never,
+      }),
+    );
+    await act(async () => finish(true));
+    expect(useRouteSearchStore.getState().categoryKey).toBeNull();
+  });
+  it("cancels a pending request when the selected entrance changes", () => {
+    fixture.addStop.mockReturnValue(new Promise(() => {}));
+    const { rerender } = render(view());
+    fireEvent.click(screen.getByText("Select stop"));
+    fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    fixture.cancel.mockClear();
+    fixture.results = [{ ...poi(), place: { ...poi().place, routingEntrance: [0.003, 0] } }];
+    rerender(view());
+    expect(fixture.cancel).toHaveBeenCalled();
+    expect(screen.getByRole("button", { name: "Add" }).hasAttribute("disabled")).toBe(false);
+  });
+  it("labels approximation and coordinate fallback", () => {
+    render(view());
+    fireEvent.click(screen.getByText("Select stop"));
+    expect(screen.getByText(/straight-line estimate/)).toBeTruthy();
+    expect(screen.getByText(/entrance unknown/)).toBeTruthy();
+  });
+  it("updates the selected card and disables unreachable stops", () => {
+    const { rerender } = render(view());
+    fireEvent.click(screen.getByText("Select stop"));
+    fixture.results = [
+      {
+        ...poi(),
+        detour: {
+          id: "stop",
+          kind: "network",
+          seconds: 600,
+          meters: 4000,
+          provider: "routing-fixture",
+          access: { kind: "entrance", coordinates: [0.002, 0] },
+          waypoints: [],
+        },
+      },
+    ];
+    rerender(view());
+    expect(screen.getByText("+10 min by road")).toBeTruthy();
+    expect(screen.getByText("+4.0 km")).toBeTruthy();
+    expect(screen.getByText("Routing to known entrance")).toBeTruthy();
+    fixture.results = [
+      {
+        ...poi(),
+        detour: {
+          id: "stop",
+          kind: "unreachable",
+          access: { kind: "coordinate", coordinates: [0.001, 0.001] },
+          waypoints: [],
+        },
+      },
+    ];
+    rerender(view());
+    expect(screen.getByText("No route to this stop")).toBeTruthy();
+    expect(screen.getByRole("button", { name: "Add" }).hasAttribute("disabled")).toBe(true);
+  });
+  it("cancels a pending selection when the card is dismissed", () => {
+    fixture.addStop.mockReturnValue(new Promise(() => {}));
+    render(view());
+    fireEvent.click(screen.getByText("Select stop"));
+    fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    fixture.cancel.mockClear();
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(fixture.cancel).toHaveBeenCalled();
+  });
+});
diff --git a/apps/web/src/components/navigation/RouteSearchControl.tsx b/apps/web/src/components/navigation/RouteSearchControl.tsx
index 7b14cb538..ecdec6ef6 100644
--- a/apps/web/src/components/navigation/RouteSearchControl.tsx
+++ b/apps/web/src/components/navigation/RouteSearchControl.tsx
@@ -33,6 +33,7 @@ import { BrandLogo } from "@/components/search/BrandLogo";
 import { useMapOptional } from "@/integration-api/map/MapContext";
 import { BRAND } from "@/integration-api/runtime/theme";
 import { useRouteSearchStore } from "@/lib/navigation/routeSearchStore";
+import { routeStopCopy } from "@/lib/navigation/routeStopCopy";
 import { routeSearchQueryFor, useRouteSearch } from "@/lib/navigation/useRouteSearch";
 import { RouteSearchResultsLayer } from "./RouteSearchResultsLayer";
 
@@ -101,8 +102,10 @@ export function RouteSearchControl() {
   const setBrand = useRouteSearchStore((s) => s.setBrand);
   const resetStore = useRouteSearchStore((s) => s.reset);
   const setCameraMode = useNavigationStore((s) => s.setCameraMode);
-  const [selected, setSelected] = useState<AlongRoutePoi<CategoryPlace> | null>(null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
   const [adding, setAdding] = useState(false);
+  const [addFailed, setAddFailed] = useState(false);
+  const selectionIntent = useRef(0);
   const [brandQuery, setBrandQuery] = useState("");
   const debouncedBrandQuery = useDebounce(brandQuery, 200);
   const { data: brandSuggestData } = useBrandSuggest(debouncedBrandQuery);
@@ -119,7 +122,33 @@ export function RouteSearchControl() {
     : brand
       ? routeSearchQueryFor({ brand })
       : null;
-  const { results, isLoading, addStop } = useRouteSearch(query);
+  const { results, isLoading, addStop, cancelAddStop } = useRouteSearch(query);
+  const selected = results.find((poi) => poi.place.id === selectedId) ?? null;
+  const copy = selected ? routeStopCopy(selected) : null;
+  // A new search or route must retire any pending selection in this sheet.
+  const route = useNavigationStore((s) => s.route);
+  const session = useNavigationStore((s) => s.navigationStartedAtMs);
+  useEffect(() => {
+    void activeKey;
+    void route;
+    void session;
+    selectionIntent.current++;
+    setSelectedId(null);
+    setAdding(false);
+    setAddFailed(false);
+    cancelAddStop();
+  }, [activeKey, route, session, cancelAddStop]);
+  const selectedTarget = selected?.place.routingEntrance ?? selected?.place.coordinates;
+  const targetLng = selectedTarget?.[0];
+  const targetLat = selectedTarget?.[1];
+  useEffect(() => {
+    void targetLng;
+    void targetLat;
+    selectionIntent.current++;
+    cancelAddStop();
+    setAdding(false);
+    setAddFailed(false);
+  }, [targetLng, targetLat, cancelAddStop]);
 
   const handleSelectBrand = (b: BrandSummary) => {
     setBrand(b);
@@ -174,13 +203,21 @@ export function RouteSearchControl() {
   }, [searching, results]);
 
   const reset = () => {
+    selectionIntent.current++;
+    cancelAddStop();
     resetStore();
-    setSelected(null);
+    setSelectedId(null);
+    setAdding(false);
+    setAddFailed(false);
     setBrandQuery("");
   };
 
   const handleSelect = (poi: AlongRoutePoi<CategoryPlace>) => {
-    setSelected(poi);
+    selectionIntent.current++;
+    cancelAddStop();
+    setSelectedId(poi.place.id);
+    setAdding(false);
+    setAddFailed(false);
     mapCtx?.flyTo(poi.place.coordinates, 15);
   };
 
@@ -190,10 +227,19 @@ export function RouteSearchControl() {
 
   const handleAdd = async () => {
     if (!selected) return;
+    const intent = ++selectionIntent.current;
+    setAddFailed(false);
     setAdding(true);
-    const ok = await addStop(selected.place.coordinates);
+    const ok = await addStop(selected.place);
+    // Success means this selection committed. Its route change also retires
+    // the card's intent, so complete search before guarding stale failures.
+    if (ok) {
+      reset();
+      return;
+    }
+    if (intent !== selectionIntent.current) return;
     setAdding(false);
-    if (ok) reset();
+    setAddFailed(true);
   };
 
   return (
@@ -378,13 +424,41 @@ export function RouteSearchControl() {
               <Typography variant="subtitle1" sx={{ fontWeight: 600 }} noWrap>
                 {selected.place.name}
               </Typography>
-              <Typography variant="body2" color="text.secondary">
-                {t("rsDetour", { minutes: Math.max(1, Math.round(selected.detourSeconds / 60)) })}
+              <Typography variant="body2" color="text.secondary" aria-live="polite">
+                {copy && t(copy.key, copy.values)}
               </Typography>
+              {selected.detour?.kind === "network" && (
+                <Typography variant="body2" color="text.secondary">
+                  {t("rsDetourDistance", {
+                    kilometers: (selected.detour.meters / 1000).toFixed(1),
+                  })}
+                </Typography>
+              )}
             </Box>
           </Box>
+          <Typography variant="caption" color="text.secondary" sx={{ display: "block", mb: 1.5 }}>
+            {t(
+              selected.detour?.access.kind === "entrance" || selected.place.routingEntrance
+                ? "rsDetourEntrance"
+                : "rsDetourCoordinate",
+            )}
+          </Typography>
+          {addFailed && (
+            <Typography role="alert" color="error" variant="body2" sx={{ mb: 1 }}>
+              {t("rsAddFailed")}
+            </Typography>
+          )}
           <Box sx={{ display: "flex", gap: 1, justifyContent: "flex-end" }}>
-            <Button onClick={() => setSelected(null)} color="inherit">
+            <Button
+              onClick={() => {
+                selectionIntent.current++;
+                cancelAddStop();
+                setSelectedId(null);
+                setAdding(false);
+                setAddFailed(false);
+              }}
+              color="inherit"
+            >
               {t("rsCancel")}
             </Button>
             <Button
@@ -392,7 +466,7 @@ export function RouteSearchControl() {
               startIcon={
                 adding ? <CircularProgress size={16} color="inherit" /> : <AddLocationAltIcon />
               }
-              disabled={adding}
+              disabled={adding || selected.detour?.kind === "unreachable"}
               onClick={handleAdd}
             >
               {t("rsAdd")}
diff --git a/apps/web/src/components/navigation/RouteSearchResultsLayer.test.tsx b/apps/web/src/components/navigation/RouteSearchResultsLayer.test.tsx
index c3dea1494..a5bd53c45 100644
--- a/apps/web/src/components/navigation/RouteSearchResultsLayer.test.tsx
+++ b/apps/web/src/components/navigation/RouteSearchResultsLayer.test.tsx
@@ -3,6 +3,13 @@ import type { AlongRoutePoi, CategoryPlace } from "@openmapx/core";
 import { act, render, waitFor } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+vi.mock("next-intl", async () => {
+  const { createTranslator } = await vi.importActual<typeof import("next-intl")>("next-intl");
+  const { default: messages } = await import("@openmapx/i18n/locales/en.json");
+  const translate = createTranslator({ locale: "en", messages, namespace: "navigation" });
+  return { useTranslations: () => translate };
+});
+
 const fixtures = vi.hoisted(() => ({
   publish: vi.fn(),
   loadBrand: vi.fn(),
@@ -47,6 +54,34 @@ beforeEach(() => {
   fixtures.map.isStyleLoaded.mockReturnValue(true);
 });
 describe("RouteSearchResultsLayer brand pins", () => {
+  it("labels unknown and unreachable detours without short geometric minutes", () => {
+    const unknown = {
+      ...results[0],
+      detour: {
+        id: "lidl",
+        kind: "unknown",
+        access: { kind: "coordinate", coordinates: [13, 52] },
+        waypoints: [],
+      },
+    } as AlongRoutePoi<CategoryPlace>;
+    const { rerender } = render(<RouteSearchResultsLayer {...props} results={[unknown]} />);
+    const label = () =>
+      (
+        fixtures.publish.mock.calls.at(-1)?.[0] as
+          | { data: { features: { properties: { label: string } }[] } }[]
+          | undefined
+      )?.[0].data.features[0].properties.label;
+    expect(label()).toBe("Unknown detour");
+    rerender(
+      <RouteSearchResultsLayer
+        {...props}
+        results={[{ ...unknown, detour: { ...unknown.detour!, kind: "unreachable" } }]}
+      />,
+    );
+    expect(label()).toBe("Unreachable");
+    rerender(<RouteSearchResultsLayer {...props} />);
+    expect(label()).toBe("~+2 min");
+  });
   it("publishes the selected brand logo after it loads", async () => {
     fixtures.loadBrand.mockResolvedValue(true);
     render(<RouteSearchResultsLayer {...props} brandQid="Q151954" />);
diff --git a/apps/web/src/components/navigation/RouteSearchResultsLayer.tsx b/apps/web/src/components/navigation/RouteSearchResultsLayer.tsx
index 8bb5482e2..e24432ccc 100644
--- a/apps/web/src/components/navigation/RouteSearchResultsLayer.tsx
+++ b/apps/web/src/components/navigation/RouteSearchResultsLayer.tsx
@@ -2,6 +2,7 @@
 
 import type { AlongRoutePoi, CategoryPlace } from "@openmapx/core";
 import type * as maplibregl from "maplibre-gl";
+import { useTranslations } from "next-intl";
 import { useEffect, useState } from "react";
 import { brandImageId, loadBrandMarkerImage } from "@/components/map/CategoryResultMarkers";
 import { addLayerInSlot } from "@/integration-api/map/layerStack";
@@ -10,6 +11,7 @@ import { getMapClickOwner } from "@/integration-api/map/mapClickOwnership";
 import { useGeoJsonSourceDataBridge } from "@/integration-api/map/useGeoJsonSourceDataBridge";
 import { BRAND_HEX } from "@/integration-api/runtime/theme";
 import { createMarkerSvg } from "@/lib/markerSvg";
+import { routeStopCopy } from "@/lib/navigation/routeStopCopy";
 
 const SOURCE = "route-search-source";
 const LAYER = "route-search-layer";
@@ -49,6 +51,7 @@ export function RouteSearchResultsLayer({
   onSelect: (poi: AlongRoutePoi<CategoryPlace>) => void;
 }) {
   const { mapRef, mapReady, styleVersion } = useMap();
+  const t = useTranslations("navigation");
   const fallbackImageId = `route-search-pin-${categoryKey}`;
   const [loadedBrand, setLoadedBrand] = useState<{ qid: string; styleVersion: number } | null>(
     null,
@@ -123,19 +126,22 @@ export function RouteSearchResultsLayer({
         sourceId: SOURCE,
         data: {
           type: "FeatureCollection",
-          features: results.map((poi) => ({
-            type: "Feature" as const,
-            properties: {
-              id: poi.place.id,
-              imageId,
-              label: `+${Math.max(1, Math.round(poi.detourSeconds / 60))} min`,
-            },
-            geometry: { type: "Point" as const, coordinates: poi.place.coordinates },
-          })),
+          features: results.map((poi) => {
+            const copy = routeStopCopy(poi, true);
+            return {
+              type: "Feature" as const,
+              properties: {
+                id: poi.place.id,
+                imageId,
+                label: t(copy.key, copy.values),
+              },
+              geometry: { type: "Point" as const, coordinates: poi.place.coordinates },
+            };
+          }),
         },
       },
     ]);
-  }, [imageId, publishGeoJson, results, styleVersion]);
+  }, [imageId, publishGeoJson, results, styleVersion, t]);
 
   useEffect(() => {
     const map = mapRef.current;
diff --git a/apps/web/src/lib/navigation/routeStopCopy.ts b/apps/web/src/lib/navigation/routeStopCopy.ts
new file mode 100644
index 000000000..ee7f73822
--- /dev/null
+++ b/apps/web/src/lib/navigation/routeStopCopy.ts
@@ -0,0 +1,20 @@
+import type { AlongRoutePoi, CategoryPlace } from "@openmapx/core";
+
+/** Shared confidence copy for map labels and the selected card. */
+export function routeStopCopy(poi: AlongRoutePoi<CategoryPlace>, compact = false) {
+  const kind = poi.detour?.kind;
+  const minutes = Math.max(
+    0,
+    Math.ceil((poi.detour?.kind === "network" ? poi.detour.seconds : poi.detourSeconds) / 60),
+  );
+  if (kind === "network")
+    return { key: compact ? "rsPinNetwork" : "rsDetourNetwork", values: { minutes } } as const;
+  if (kind === "unreachable")
+    return { key: compact ? "rsPinUnreachable" : "rsDetourUnreachable" } as const;
+  if (kind === "unknown") return { key: compact ? "rsPinUnknown" : "rsDetourUnknown" } as const;
+  if (poi.detourPending) return { key: compact ? "rsPinChecking" : "rsDetourChecking" } as const;
+  return {
+    key: compact ? "rsPinApproximate" : "rsDetourApproximate",
+    values: { minutes },
+  } as const;
+}
diff --git a/apps/web/src/lib/navigation/useRouteSearch.test.tsx b/apps/web/src/lib/navigation/useRouteSearch.test.tsx
index 7915868be..eb3f4d55e 100644
--- a/apps/web/src/lib/navigation/useRouteSearch.test.tsx
+++ b/apps/web/src/lib/navigation/useRouteSearch.test.tsx
@@ -2,16 +2,18 @@
 
 import type { Route } from "@integrations/routing/types";
 import {
+  type DirectionsResult,
   type OverpassFilter,
   readRouteMatcherCounters,
   resetRouteMatcherCounters,
   setRouteMatcherCounting,
   useNavigationStore,
 } from "@openmapx/core";
-import { act, renderHook } from "@testing-library/react";
+import { act, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("next-intl", () => ({ useLocale: () => "en" }));
+const directions = vi.hoisted(() => vi.fn());
 
 // POIs along the corridor, standing in for the category search response.
 const places = [
@@ -19,6 +21,7 @@ const places = [
   { id: "b", name: "B", coordinates: [0.002, -0.0003] },
   { id: "c", name: "C", coordinates: [0.003, 0.0001] },
 ];
+let categoryPlaces: ((typeof places)[number] & { routingEntrance?: [number, number] })[] = places;
 
 // A deliberately different-shaped fixture for the filter search response —
 // different ids, names, coordinates, *and* length (2 vs 3) from `places`. If
@@ -48,8 +51,9 @@ vi.mock("@openmapx/core", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@openmapx/core")>();
   return {
     ...actual,
+    fetchDirections: directions,
     useCategorySearch: () => ({
-      data: { results: places },
+      data: { results: categoryPlaces },
       isLoading: false,
       isError: false,
     }),
@@ -94,18 +98,324 @@ const publishProgress = (alongMeters: number) => {
 };
 
 describe("useRouteSearch route index ownership", () => {
+  it("uses the refreshed coordinate when selecting a place by its retained identity", async () => {
+    const previous = { ...places[0], coordinates: [0.001, 0.0002] as [number, number] };
+    const { result, rerender, unmount } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    categoryPlaces = places.map((p) =>
+      p.id === previous.id ? { ...p, coordinates: [0.0019, 0] } : p,
+    );
+    rerender();
+    await act(async () => {});
+    directions.mockResolvedValue({
+      waypoints,
+      activeRouteIndex: 0,
+      provider: "routing-fixture",
+      routes: [freshRoute()],
+    });
+    await act(async () => {
+      expect(await result.current.addStop(previous)).toBe(true);
+    });
+    unmount();
+    expect(useNavigationStore.getState().destinationWaypoints[1]).toEqual([0.0019, 0]);
+  });
+  it("uses the selected identity for co-located stops with different entrances", async () => {
+    categoryPlaces = [
+      { ...places[0], id: "a", routingEntrance: [0.0019, 0] },
+      { ...places[0], id: "b", routingEntrance: [0.0021, 0] },
+    ];
+    const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    await act(async () => {});
+    directions.mockResolvedValue({
+      waypoints,
+      activeRouteIndex: 0,
+      provider: "routing-fixture",
+      routes: [freshRoute()],
+    });
+    await act(async () => {
+      expect(await result.current.addStop({ id: "b", coordinates: [0.001, 0.0002] } as never)).toBe(
+        true,
+      );
+    });
+    expect(useNavigationStore.getState().destinationWaypoints[1]).toEqual([0.0021, 0]);
+  });
+  it("pins and retains the baseline-selected provider when the active route has none", async () => {
+    directions.mockResolvedValue({
+      waypoints,
+      activeRouteIndex: 0,
+      provider: "routing-a",
+      routes: [freshRoute()],
+    });
+    const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    await waitFor(() => expect(result.current.results[0].detour?.kind).toBe("network"));
+    directions.mockClear();
+    await act(async () => {
+      expect(await result.current.addStop([0.001, 0.0002])).toBe(true);
+    });
+    expect(directions.mock.calls[0][0]).toMatchObject({ provider: "routing-a" });
+    expect(useNavigationStore.getState().routeProvider).toBe("routing-a");
+  });
+  it("rejects an old entrance after the selected candidate target refreshes", async () => {
+    const { result, rerender } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    let finish!: (value: DirectionsResult) => void;
+    let requested = false;
+    directions.mockImplementation(() => {
+      if (requested) return Promise.reject(new Error("offline"));
+      requested = true;
+      return new Promise((resolve) => {
+        finish = resolve;
+      });
+    });
+    let pending!: Promise<boolean>;
+    act(() => {
+      pending = result.current.addStop([0.001, 0.0002]);
+    });
+    const signal = (directions.mock.calls.at(-1)?.[2] as { signal: AbortSignal }).signal;
+    categoryPlaces = places.map((p) => (p.id === "a" ? { ...p, coordinates: [0.0019, 0] } : p));
+    rerender();
+    expect(signal.aborted).toBe(true);
+    await act(async () => {
+      finish({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      expect(await pending).toBe(false);
+    });
+    expect(useNavigationStore.getState().destinationWaypoints).toEqual(waypoints);
+    expect(useNavigationStore.getState().status).toBe("navigating");
+  });
   beforeEach(() => {
+    directions.mockReset().mockRejectedValue(new Error("offline"));
     useNavigationStore.getState().stopNavigation();
     useNavigationStore.getState().startGroundNavigation(freshRoute(), "driving", waypoints);
     resetRouteMatcherCounters();
     setRouteMatcherCounting(true);
   });
 
+  it("publishes network deltas and keeps provider/options on every comparison", async () => {
+    const route = freshRoute();
+    useNavigationStore
+      .getState()
+      .startGroundNavigation(route, "driving", waypoints, [], "routing-fixture", {
+        routeOptions: {
+          avoidTolls: true,
+          avoidHighways: true,
+          avoidFerries: true,
+          avoidClosures: true,
+        },
+      });
+    directions.mockImplementation(async (value: unknown) => {
+      const { waypoints: points } = value as { waypoints: [number, number][] };
+      return {
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [
+          {
+            ...route,
+            duration: points.length === 2 ? 60 : 180,
+            distance: points.length === 2 ? 444 : 1444,
+          },
+        ],
+      };
+    });
+    const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    await waitFor(() => expect(result.current.results[0].detour?.kind).toBe("network"));
+    expect(result.current.results[0].detourSeconds).toBe(120);
+    expect(result.current.results[0].detourMeters).toBe(1000);
+    for (const [params, , options] of directions.mock.calls) {
+      expect(params).toMatchObject({
+        provider: "routing-fixture",
+        avoidTolls: true,
+        avoidHighways: true,
+        avoidFerries: true,
+        avoidClosures: true,
+      });
+      expect((options as { signal: AbortSignal } | undefined)?.signal).toBeInstanceOf(AbortSignal);
+    }
+    const calls = directions.mock.calls.length;
+    for (let i = 1; i <= 5; i++) act(() => publishProgress(i * 10));
+    expect(directions).toHaveBeenCalledTimes(calls);
+  });
+
+  it("invalidates a held network claim immediately after provider changes", async () => {
+    const route = freshRoute();
+    directions.mockResolvedValue({
+      waypoints,
+      activeRouteIndex: 0,
+      provider: "routing-fixture",
+      routes: [route],
+    });
+    const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    await waitFor(() => expect(result.current.results[0].detour?.kind).toBe("network"));
+    directions.mockReturnValue(new Promise(() => {}));
+    act(() => useNavigationStore.setState({ routeProvider: "routing-other" }));
+    expect(result.current.results[0].detour?.kind).not.toBe("network");
+  });
+
+  it("rejects a late added stop after another session starts with the same route", async () => {
+    const { result } = renderHook(() => useRouteSearch(null));
+    const original = useNavigationStore.getState().route!;
+    let finish!: (result: DirectionsResult) => void;
+    directions.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finish = resolve;
+        }),
+    );
+    let pending!: Promise<boolean>;
+    act(() => {
+      pending = result.current.addStop([0.002, 0.0002]);
+    });
+    act(() => {
+      useNavigationStore.getState().stopNavigation();
+      useNavigationStore.getState().startGroundNavigation(original, "driving", waypoints);
+    });
+    await act(async () => {
+      finish({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      expect(await pending).toBe(false);
+    });
+    expect(useNavigationStore.getState().destinationWaypoints).toEqual(waypoints);
+    expect(useNavigationStore.getState().route).toBe(original);
+  });
+
+  it("cancels its stop request and restores navigation without committing a late response", async () => {
+    const { result } = renderHook(() => useRouteSearch(null));
+    const original = useNavigationStore.getState().route;
+    let finish!: (value: DirectionsResult) => void;
+    directions.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finish = resolve;
+        }),
+    );
+    let pending!: Promise<boolean>;
+    act(() => {
+      pending = result.current.addStop([0.002, 0.0002]);
+    });
+    const signal = (directions.mock.calls[0][2] as { signal: AbortSignal } | undefined)?.signal;
+    act(() => result.current.cancelAddStop());
+    expect(signal?.aborted).toBe(true);
+    expect(useNavigationStore.getState().status).toBe("navigating");
+    await act(async () => {
+      finish({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      expect(await pending).toBe(false);
+    });
+    expect(useNavigationStore.getState().route).toBe(original);
+  });
+
+  it("lets only the latest competing stop selection commit", async () => {
+    const { result } = renderHook(() => useRouteSearch(null));
+    const finishes: ((value: DirectionsResult) => void)[] = [];
+    directions.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishes.push(resolve);
+        }),
+    );
+    let first!: Promise<boolean>;
+    let second!: Promise<boolean>;
+    act(() => {
+      first = result.current.addStop([0.001, 0.0002]);
+    });
+    act(() => {
+      second = result.current.addStop([0.003, 0.0002]);
+    });
+    expect(directions).toHaveBeenCalledTimes(2);
+    await act(async () => {
+      finishes[1]({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      expect(await second).toBe(true);
+    });
+    await act(async () => {
+      finishes[0]({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      expect(await first).toBe(false);
+    });
+    expect(useNavigationStore.getState().destinationWaypoints).toEqual([
+      waypoints[0],
+      [0.003, 0.0002],
+      waypoints[1],
+    ]);
+  });
+
+  it("expires held estimates without polling the provider", async () => {
+    vi.useFakeTimers();
+    try {
+      directions.mockResolvedValue({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      });
+      const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+      await act(async () => {});
+      expect(result.current.results[0].detour?.kind).toBe("network");
+      const calls = directions.mock.calls.length;
+      await act(async () => vi.advanceTimersByTimeAsync(60_001));
+      expect(result.current.results[0].detour?.kind).not.toBe("network");
+      expect(directions).toHaveBeenCalledTimes(calls);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("does not evaluate or add stops in a native-owned session", async () => {
+    useNavigationStore.setState({ navigationAuthority: "native" });
+    const { result } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    expect(await result.current.addStop([0.002, 0.0002])).toBe(false);
+    expect(directions).not.toHaveBeenCalled();
+  });
+
+  it("aborts evaluation on unmount and never issues remaining candidate requests", async () => {
+    let finish!: (value: DirectionsResult) => void;
+    directions.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finish = resolve;
+        }),
+    );
+    const { unmount } = renderHook(() => useRouteSearch({ category: "fuel" }));
+    const signal = (directions.mock.calls[0]?.[2] as { signal: AbortSignal } | undefined)?.signal;
+    unmount();
+    expect(signal?.aborted).toBe(true);
+    await act(async () =>
+      finish({
+        waypoints,
+        activeRouteIndex: 0,
+        provider: "routing-fixture",
+        routes: [freshRoute()],
+      }),
+    );
+    expect(directions).toHaveBeenCalledTimes(1);
+  });
+
   afterEach(() => {
     setRouteMatcherCounting(false);
     resetRouteMatcherCounters();
+    useNavigationStore.setState({ navigationAuthority: "browser" });
     useNavigationStore.getState().stopNavigation();
     filterSearchResult = { data: undefined, isLoading: false, isError: false };
+    categoryPlaces = places;
   });
 
   it("selects the filter search over the category search when a filter is given", () => {
diff --git a/apps/web/src/lib/navigation/useRouteSearch.ts b/apps/web/src/lib/navigation/useRouteSearch.ts
index 64a0e099c..95fae5869 100644
--- a/apps/web/src/lib/navigation/useRouteSearch.ts
+++ b/apps/web/src/lib/navigation/useRouteSearch.ts
@@ -6,20 +6,30 @@ import {
   brandToFilter,
   type CategoryId,
   type CategoryPlace,
+  cumulativeDistances,
+  evaluateRouteStopDetours,
   fetchDirections,
   filterRoutePois,
+  insertRouteStop,
   type LngLat,
   type OverpassFilter,
+  paddedRouteAheadBounds,
+  positionAt,
   prepareRouteMatcher,
   projectRoutePois,
-  remainingWaypoints,
-  routeAheadBounds,
+  ROUTE_STOP_CACHE_MS,
+  ROUTE_STOP_LIMIT,
+  ROUTE_STOP_PROGRESS_METERS,
+  type RouteStopCandidate,
+  type RouteStopDetour,
+  remainingRouteStopWaypoints,
+  routeStopWaypointPositions,
   useCategorySearch,
   useFilterSearch,
   useNavigationStore,
 } from "@openmapx/core";
 import { useLocale } from "next-intl";
-import { useMemo } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 /** How far ahead along the route to search for POIs. */
 const LOOKAHEAD_M = 25_000;
@@ -63,7 +73,8 @@ export interface UseRouteSearch {
   isLoading: boolean;
   isError: boolean;
   /** Re-plan the active route through `coord` as a new stop. Resolves to success. */
-  addStop: (coord: LngLat) => Promise<boolean>;
+  addStop: (candidate: RouteStopCandidate | LngLat) => Promise<boolean>;
+  cancelAddStop: () => void;
 }
 
 /**
@@ -80,12 +91,29 @@ export function useRouteSearch(query: RouteSearchQuery | null): UseRouteSearch {
   const route = useNavigationStore((s) => s.route);
   const alongMeters = useNavigationStore((s) => s.progress?.alongMeters ?? 0);
   const speedMps = useNavigationStore((s) => s.progress?.speedMps ?? 0);
+  const mode = useNavigationStore((s) => s.mode);
+  const options = useNavigationStore((s) => s.routeOptions);
+  const provider = useNavigationStore((s) => s.routeProvider);
+  const waypoints = useNavigationStore((s) => s.destinationWaypoints);
+  const startedAt = useNavigationStore((s) => s.navigationStartedAtMs);
+  const authority = useNavigationStore((s) => s.navigationAuthority);
+  const status = useNavigationStore((s) => s.status);
+  const live = status === "navigating";
 
   // One snap index for the active route, so a results refresh projects the whole
   // POI set — and prunes the waypoints for an added stop — against the same
   // index. A position fix alone never rebuilds it.
   const geometry = route?.geometry;
   const matcher = useMemo(() => (geometry ? prepareRouteMatcher(geometry) : null), [geometry]);
+  const cumulative = useMemo(() => (geometry ? cumulativeDistances(geometry) : []), [geometry]);
+  const intermediate = useMemo(
+    () => (matcher ? routeStopWaypointPositions(matcher, waypoints) : []),
+    [matcher, waypoints],
+  );
+  // Crossing a user stop changes the remaining itinerary even within a bucket.
+  const remainingKey = intermediate
+    .map((wp) => (wp.final || wp.alongMeters > alongMeters ? "1" : "0"))
+    .join("");
 
   // Quantize so the query box (and its cache key) only changes every few km,
   // not on every position fix. Results are still filtered against the live
@@ -94,7 +122,11 @@ export function useRouteSearch(query: RouteSearchQuery | null): UseRouteSearch {
   // same cadence a category search does.
   const bboxAlong = Math.floor(alongMeters / BBOX_STEP_M) * BBOX_STEP_M;
   const bbox = useMemo(
-    () => (route ? routeAheadBounds(route.geometry, bboxAlong, LOOKAHEAD_M) : null),
+    () =>
+      route
+        ? (paddedRouteAheadBounds(route.geometry, bboxAlong, LOOKAHEAD_M + BBOX_STEP_M)?.[0] ??
+          null)
+        : null,
     [route, bboxAlong],
   );
 
@@ -119,7 +151,7 @@ export function useRouteSearch(query: RouteSearchQuery | null): UseRouteSearch {
     () => (matcher && places ? projectRoutePois(places, matcher) : []),
     [matcher, places],
   );
-  const results = useMemo(
+  const geometric = useMemo(
     () =>
       filterRoutePois(projections, alongMeters, {
         lookaheadMeters: LOOKAHEAD_M,
@@ -128,38 +160,270 @@ export function useRouteSearch(query: RouteSearchQuery | null): UseRouteSearch {
     [projections, alongMeters, speedMps],
   );
 
-  const addStop = async (coord: LngLat): Promise<boolean> => {
+  const serial = useRef(0);
+  const owner = useMemo(
+    () => ({
+      id: ++serial.current,
+      route,
+      options,
+      provider,
+      waypoints,
+      startedAt,
+      mode,
+      authority,
+    }),
+    [route, options, provider, waypoints, startedAt, mode, authority],
+  );
+  const bucket = Math.floor(alongMeters / ROUTE_STOP_PROGRESS_METERS);
+  const scope = categoryKey ?? JSON.stringify(filter);
+  const enabled = query !== null;
+  const evaluation = useMemo(() => {
+    if (!matcher || !route || !enabled || authority !== "browser" || !live) return null;
+    const reference = bucket * ROUTE_STOP_PROGRESS_METERS;
+    const from = positionAt(route.geometry, cumulative, reference).point;
+    const tail = [
+      from,
+      ...intermediate.filter((_, i) => remainingKey[i] === "1").map((wp) => wp.coordinates),
+    ];
+    const candidates = filterRoutePois(projections, reference, { lookaheadMeters: LOOKAHEAD_M })
+      .slice(0, ROUTE_STOP_LIMIT)
+      .map((poi) => poi.place);
+    const key = JSON.stringify([
+      owner.id,
+      scope,
+      locale,
+      bucket,
+      tail,
+      candidates.map((p) => [p.id, p.coordinates, p.routingEntrance]),
+    ]);
+    return { key, candidates, tail, owner };
+  }, [
+    matcher,
+    route,
+    authority,
+    live,
+    bucket,
+    projections,
+    owner,
+    scope,
+    locale,
+    enabled,
+    cumulative,
+    intermediate,
+    remainingKey,
+  ]);
+  const cache = useRef(new Map<string, { results: RouteStopDetour[]; expiresAt: number }>());
+  const targets = useMemo(
+    () =>
+      new Map(
+        (places ?? []).map((p) => [p.id, JSON.stringify([p.coordinates, p.routingEntrance])]),
+      ),
+    [places],
+  );
+  const selectionScope = useRef({ scope, enabled, locale, targets });
+  selectionScope.current = { scope, enabled, locale, targets };
+  const [verified, setVerified] = useState<{
+    key: string;
+    results: RouteStopDetour[];
+    expiresAt: number;
+  } | null>(null);
+  const [checking, setChecking] = useState<string | null>(null);
+  useEffect(() => {
+    if (!evaluation || !matcher || evaluation.candidates.length === 0) {
+      cache.current.clear();
+      setVerified(null);
+      setChecking(null);
+      return;
+    }
+    const controller = new AbortController();
+    let expiry: ReturnType<typeof setTimeout> | undefined;
+    const publish = (entry: { results: RouteStopDetour[]; expiresAt: number }) => {
+      if (controller.signal.aborted) return;
+      setVerified({ key: evaluation.key, ...entry });
+      setChecking(null);
+      expiry = setTimeout(
+        () => setVerified((current) => (current?.key === evaluation.key ? null : current)),
+        Math.max(0, entry.expiresAt - Date.now()),
+      );
+    };
+    const cached = cache.current.get(evaluation.key);
+    if (cached && cached.expiresAt > Date.now()) publish(cached);
+    else {
+      setChecking(evaluation.key);
+      void evaluateRouteStopDetours({
+        route: matcher,
+        alongMeters: bucket * ROUTE_STOP_PROGRESS_METERS,
+        waypoints: evaluation.tail,
+        candidates: evaluation.candidates,
+        provider: provider ?? undefined,
+        signal: controller.signal,
+        requestRoute: ({ waypoints, provider, signal }) =>
+          fetchDirections({ waypoints, provider, mode, ...options, lang: locale }, undefined, {
+            signal,
+            timeoutMs: 15_000,
+          }),
+      })
+        .then((results) => {
+          if (controller.signal.aborted) return;
+          const entry = { results, expiresAt: Date.now() + ROUTE_STOP_CACHE_MS };
+          cache.current.delete(evaluation.key);
+          cache.current.set(evaluation.key, entry);
+          while (cache.current.size > 64) {
+            const oldest = cache.current.keys().next().value;
+            if (oldest === undefined) break;
+            cache.current.delete(oldest);
+          }
+          publish(entry);
+        })
+        .catch(() => {
+          if (!controller.signal.aborted) setChecking(null);
+        });
+    }
+    return () => {
+      controller.abort();
+      if (expiry) clearTimeout(expiry);
+    };
+  }, [evaluation, matcher, provider, mode, options, locale, bucket]);
+  const results = useMemo(() => {
+    const current =
+      verified?.key === evaluation?.key && verified && verified.expiresAt > Date.now()
+        ? verified.results
+        : [];
+    const estimates = new Map(current.map((detour) => [detour.id, detour]));
+    return geometric.map((poi) => {
+      const detour = estimates.get(poi.place.id);
+      return {
+        ...poi,
+        ...(detour ? { detour } : {}),
+        ...(checking === evaluation?.key &&
+        evaluation?.candidates.some((p) => p.id === poi.place.id)
+          ? { detourPending: true }
+          : {}),
+        ...(detour?.kind === "network"
+          ? { detourSeconds: detour.seconds, detourMeters: detour.meters }
+          : {}),
+      };
+    });
+  }, [geometric, verified, evaluation, checking]);
+  const adding = useRef<{
+    controller: AbortController;
+    ownsRoute: () => boolean;
+    selectionCurrent: () => boolean;
+  } | null>(null);
+  const cancelAddStop = useCallback(() => {
+    const pending = adding.current;
+    if (!pending) return;
+    const restore = pending.ownsRoute();
+    pending.controller.abort();
+    adding.current = null;
+    if (restore) useNavigationStore.setState({ status: "navigating" });
+  }, []);
+  useEffect(() => {
+    void scope;
+    void enabled;
+    void locale;
+    void targets;
+    if (adding.current && !adding.current.selectionCurrent()) cancelAddStop();
+  }, [scope, enabled, locale, targets, cancelAddStop]);
+  useEffect(
+    () => () => {
+      cancelAddStop();
+      cache.current.clear();
+    },
+    [cancelAddStop],
+  );
+
+  const addStop = async (selection: RouteStopCandidate | LngLat): Promise<boolean> => {
+    cancelAddStop();
     const store = useNavigationStore.getState();
     const { route: r, mode, destinationWaypoints, progress } = store;
-    if (!r) return false;
+    if (!r || store.navigationAuthority !== "browser" || store.status !== "navigating")
+      return false;
+    const controller = new AbortController();
+    const coord = Array.isArray(selection) ? selection : selection.coordinates;
+    const matches = results.filter((poi) =>
+      Array.isArray(selection)
+        ? poi.place.coordinates[0] === coord[0] && poi.place.coordinates[1] === coord[1]
+        : poi.place.id === selection.id,
+    );
+    // Coordinate-only compatibility callers cannot disambiguate co-located sites.
+    if (matches.length > 1 || (!Array.isArray(selection) && matches.length !== 1)) return false;
+    const candidate = matches[0];
+    if (candidate?.detour?.kind === "unreachable") return false;
+    const requestedProvider =
+      store.routeProvider ??
+      (candidate?.detour?.kind === "network" ? candidate.detour.provider : undefined);
+    const captured = selectionScope.current;
+    const selectedTarget = candidate
+      ? JSON.stringify([candidate.place.coordinates, candidate.place.routingEntrance])
+      : undefined;
+    const selectionCurrent = () => {
+      const current = selectionScope.current;
+      return (
+        current.scope === captured.scope &&
+        current.enabled === captured.enabled &&
+        current.locale === captured.locale &&
+        (!candidate || current.targets.get(candidate.place.id) === selectedTarget)
+      );
+    };
+    if (!selectionCurrent()) return false;
+    const target = candidate?.place.routingEntrance ?? candidate?.place.coordinates ?? coord;
     const from = progress?.snapped ?? destinationWaypoints[0] ?? coord;
     // The store's route wins if a reroute landed since the last render, in which
     // case the memoized index no longer describes it and the geometry is used.
-    const tail = remainingWaypoints(
+    const positions =
+      r === route && destinationWaypoints === waypoints
+        ? intermediate
+        : routeStopWaypointPositions(r.geometry, destinationWaypoints);
+    const tail = remainingRouteStopWaypoints(positions, from, progress?.alongMeters ?? 0);
+    const nextWaypoints = insertRouteStop(
       matcher?.geometry === r.geometry ? matcher : r.geometry,
-      destinationWaypoints,
-      from,
+      tail,
+      target,
       progress?.alongMeters ?? 0,
     );
-    // Insert the chosen POI just before the final destination.
-    const dest = tail[tail.length - 1];
-    const waypoints = [...tail.slice(0, -1), coord, dest];
+    if (nextWaypoints.length < 3) return false;
 
     store.beginReroute();
-    const stillNavigating = () => {
-      const st = useNavigationStore.getState().status;
-      return st !== "idle" && st !== "arrived";
+    const ownsRoute = () => {
+      const current = useNavigationStore.getState();
+      return (
+        current.route === r &&
+        current.routeOptions === store.routeOptions &&
+        current.routeProvider === store.routeProvider &&
+        current.destinationWaypoints === destinationWaypoints &&
+        current.navigationStartedAtMs === store.navigationStartedAtMs &&
+        current.navigationAuthority === "browser" &&
+        current.status === "rerouting"
+      );
     };
+    const pending = { controller, ownsRoute, selectionCurrent };
+    adding.current = pending;
+    const stillNavigating = () =>
+      !controller.signal.aborted && adding.current === pending && ownsRoute() && selectionCurrent();
+    const unsubscribe = useNavigationStore.subscribe(() => {
+      if (!stillNavigating()) controller.abort();
+    });
     try {
-      const res = await fetchDirections({ waypoints, mode, lang: locale });
+      const res = await fetchDirections(
+        {
+          waypoints: nextWaypoints,
+          mode,
+          provider: requestedProvider,
+          ...store.routeOptions,
+          lang: locale,
+        },
+        undefined,
+        { signal: controller.signal, timeoutMs: 15_000 },
+      );
       if (!stillNavigating()) return false;
       const next = res.routes?.[res.activeRouteIndex ?? 0];
-      if (!next) {
+      if (!next || (requestedProvider && res.provider !== requestedProvider)) {
         useNavigationStore.setState({ status: "navigating" });
         useNavigationStore.getState().signalRerouteFailed();
         return false;
       }
-      useNavigationStore.getState().addStop(next, waypoints);
+      useNavigationStore.getState().addStop(next, nextWaypoints, res.provider);
       return true;
     } catch {
       if (stillNavigating()) {
@@ -167,8 +431,14 @@ export function useRouteSearch(query: RouteSearchQuery | null): UseRouteSearch {
         useNavigationStore.getState().signalRerouteFailed();
       }
       return false;
+    } finally {
+      unsubscribe();
+      if (adding.current === pending) {
+        if (ownsRoute()) useNavigationStore.setState({ status: "navigating" });
+        adding.current = null;
+      }
     }
   };
 
-  return { results, isLoading: active.isLoading, isError: active.isError, addStop };
+  return { results, isLoading: active.isLoading, isError: active.isError, addStop, cancelAddStop };
 }
diff --git a/docs/docs/developer/navigation-performance.md b/docs/docs/developer/navigation-performance.md
index 4f8f9c4d4..f30dbca8d 100644
--- a/docs/docs/developer/navigation-performance.md
+++ b/docs/docs/developer/navigation-performance.md
@@ -209,6 +209,47 @@ Whatever the outcome, link the residual trace and the decision from here —
 including a justified "no Worker" or "no native spike" conclusion when the
 evidence does not support one.
 
+## Route-stop comparisons
+
+`@openmapx/core/navigation` exports `routeStopWaypointPositions`,
+`remainingRouteStopWaypoints`, `insertRouteStop`, `routeStopAccess`, and
+`evaluateRouteStopDetours`. Waypoint positions are resolved in itinerary order
+on successive route suffixes, preserving later visits to a retraced road. Pass
+the reference `alongMeters` when evaluating or inserting into a remaining route.
+The evaluator accepts an injected directions request
+port: callers must close over identical mode and routing preferences for baseline
+and candidate requests. Its typed results distinguish network deltas, unknown
+responses and explicit no-route results; an absent `AlongRoutePoi.detour` is a
+geometric approximation. A source can supply `CategoryPlace.routingEntrance`;
+ordinary coordinates remain an explicit fallback. This contract can be reused by
+future richer stop discovery without changing its routing semantics.
+
+The web hook evaluates six candidates, two at a time, after one baseline. It
+pins an enabled integration using the optional directions `provider` parameter;
+normal unpinned routing retains its fallback chain, while a pin never falls back
+to another graph or bypasses capability/source-policy checks. Mode-only matrices
+are deliberately not used because they cannot carry the active avoid options.
+
+The comparison origin advances in 500 m buckets. Waypoint membership changes
+invalidate a bucket, while speed and ordinary position fixes only refilter
+retained projections. Cache identity includes route/session, provider, preferences,
+query, reference position, remaining waypoints, and candidate coordinates/entrance.
+The mounted search retains at most 64 evaluations for 60 seconds, with an expiry
+invalidation timer and no routing polling timer. Requests receive AbortSignals;
+route/session replacement, search exit and unmount invalidate ownership. Adding a
+stop uses the live position and selected place ID, resolving its current entrance
+or coordinate from the latest results, so co-located places retain their distinct
+entrances and stale selection coordinates cannot override a refreshed target.
+A refreshed entrance cancels a pending selection.
+Only the latest browser-owned request may commit or restore navigation state.
+When the original route has no provider recorded, adding a verified stop pins
+and persists the provider selected by its baseline comparison.
+
+Regression fixtures define a directed road graph independently of the geometric
+projection, including a wrong-side motorway facility, a river crossing, a
+restricted stop and an ordinary urban stop. Hook tests cover option fidelity,
+request cadence, expiry, cancellation and same-route session replacement.
+
 ## Maintenance
 
 The HUD is an instrument, not a product feature. Before adding a permanent
diff --git a/docs/docs/features/directions.md b/docs/docs/features/directions.md
index 9458eb5f1..c6f703554 100644
--- a/docs/docs/features/directions.md
+++ b/docs/docs/features/directions.md
@@ -338,6 +338,44 @@ navigation UI behaves the same on Valhalla and OSRM. Valhalla additionally backs
 map-matching endpoint that snaps a recorded GPS trace to the road network — used
 for features such as placing traffic-signal markers along the active route.
 
+### Search for a stop along your route
+
+Choose a category or chain from **Search along route** while navigating. Discovery
+looks up to 25 km ahead within a 1,200 m geometric corridor. That cheap discovery
+step does not prove road access: a nearby service area may be across a motorway
+or river.
+
+For a shortlist of six stops, OpenMapX compares the complete remaining itinerary
+with and without each stop. **By road** labels show the extra routing time; the
+card also shows extra distance. Both itineraries use the active mode, avoidance
+preferences and routing provider. Existing user stops keep their order, and the
+new stop is inserted before the next stop beyond its position on the route.
+
+A known routing entrance is preferred when the place source supplies one.
+Otherwise the card explicitly says it routes to place coordinates and the
+entrance is unknown. A network estimate does not verify that a coordinate is an
+entrance or that a business is open.
+
+- **Straight-line estimate / ~**: only geometric distance and speed are available.
+- **Checking**: the road comparison is pending.
+- **Unavailable / unknown**: the provider failed, returned unusable data, or could
+  not honor the pinned routing request.
+- **No route / unreachable**: the provider returned no route through that stop.
+  Adding it is disabled.
+
+Comparisons use a route position rounded down to 500 m and expire after 60 seconds.
+Position fixes within that bucket do not issue new routing requests; passing a
+user waypoint changes the remaining itinerary immediately. Route, provider,
+preference and search changes remove old estimates. Expiry restores approximate
+labels without polling the provider. The browser cache holds at most 64
+comparisons, and only two candidate requests run concurrently after one shared
+baseline. Discovery bounds move every 5 km.
+
+**Add** replans from the current position using the same insertion rules. **Cancel**
+can dismiss a pending selection; a late response cannot change a newer route or
+navigation session. This uses the existing routing configuration and adds no
+admin setting.
+
 ## Flights: a deep-link, not live data
 
 Selecting the **flying** mode does not route an air leg or fetch live flight
diff --git a/integrations/routing/__tests__/provider-pin.test.ts b/integrations/routing/__tests__/provider-pin.test.ts
new file mode 100644
index 000000000..d82b02c34
--- /dev/null
+++ b/integrations/routing/__tests__/provider-pin.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import {
+  createDirectionsCacheIdentity,
+  DIRECTIONS_REQUEST_POLICY,
+  parseDirectionsRequest,
+} from "../directions-request";
+import {
+  createDirectionsResult,
+  createRoutingHandlerEnvironment,
+  createRoutingTestReply,
+} from "./support/routing-handler-contract";
+
+const query = { waypoints: "0,0;0.002,0", mode: "driving", provider: "routing-second" };
+
+describe("pinned directions provider", () => {
+  it("routes with the requested compatible provider instead of the default", async () => {
+    const environment = createRoutingHandlerEnvironment({
+      routingProviders: [
+        {
+          integrationId: "routing-first",
+          providerId: "first",
+          getRoute: async () => createDirectionsResult(),
+        },
+        {
+          integrationId: "routing-second",
+          providerId: "second",
+          getRoute: async () => createDirectionsResult(),
+        },
+      ],
+    });
+    const reply = createRoutingTestReply();
+    await environment.getHandler("/directions")({ query }, reply);
+    expect(reply.code).toBe(200);
+    expect(reply.body).toMatchObject({ provider: "routing-second" });
+  });
+
+  it("does not fall back when the requested provider fails", async () => {
+    const environment = createRoutingHandlerEnvironment({
+      routingProviders: [
+        {
+          integrationId: "routing-first",
+          providerId: "first",
+          getRoute: async () => createDirectionsResult(),
+        },
+        {
+          integrationId: "routing-second",
+          providerId: "second",
+          getRoute: async () => {
+            throw new Error("offline");
+          },
+        },
+      ],
+    });
+    const reply = createRoutingTestReply();
+    await environment.getHandler("/directions")({ query }, reply);
+    expect(reply.code).toBe(502);
+  });
+
+  it("does not bypass required exclusion capabilities", async () => {
+    const environment = createRoutingHandlerEnvironment({
+      closurePoints: [[0.001, 0]],
+      routingProviders: [
+        {
+          integrationId: "routing-second",
+          providerId: "second",
+          supportsExclusions: false,
+          getRoute: async () => createDirectionsResult(),
+        },
+        {
+          integrationId: "routing-aware",
+          providerId: "aware",
+          supportsExclusions: true,
+          getRoute: async () => createDirectionsResult(),
+        },
+      ],
+    });
+    const reply = createRoutingTestReply();
+    await environment.getHandler("/directions")({ query: { ...query, avoidClosures: "1" } }, reply);
+    expect(reply.code).toBe(503);
+  });
+
+  it("rejects malformed pins and separates pinned cache identities", () => {
+    expect(() =>
+      parseDirectionsRequest({ ...query, provider: "https://host" }, DIRECTIONS_REQUEST_POLICY),
+    ).toThrow();
+    const a = parseDirectionsRequest(query, DIRECTIONS_REQUEST_POLICY);
+    const b = parseDirectionsRequest(
+      { ...query, provider: "routing-first" },
+      DIRECTIONS_REQUEST_POLICY,
+    );
+    expect(createDirectionsCacheIdentity(a, null)).not.toEqual(
+      createDirectionsCacheIdentity(b, null),
+    );
+  });
+});
diff --git a/integrations/routing/directions-request.ts b/integrations/routing/directions-request.ts
index 2269215a5..c5abc7e84 100644
--- a/integrations/routing/directions-request.ts
+++ b/integrations/routing/directions-request.ts
@@ -42,6 +42,7 @@ export interface ParsedDirectionsRequest {
   travelMode: TravelMode;
   avoidClosures: boolean;
   requireTimeAware: boolean;
+  provider?: string;
   routingOptions: ParsedRoutingOptions;
 }
 
@@ -109,6 +110,9 @@ export function parseDirectionsRequest(
     if (departAt && arriveBy) {
       throw new Error("departAt and arriveBy are mutually exclusive");
     }
+    if (query.provider !== undefined && !/^[a-z0-9][a-z0-9-]{0,127}$/.test(query.provider)) {
+      throw new Error("provider must be a routing integration ID");
+    }
 
     return {
       operation: policy.operation,
@@ -116,6 +120,7 @@ export function parseDirectionsRequest(
       travelMode,
       avoidClosures: query.avoidClosures === "true" || query.avoidClosures === "1",
       requireTimeAware: Boolean(departAt || arriveBy),
+      ...(query.provider && { provider: query.provider }),
       routingOptions: {
         avoidHighways: query.avoidHighways === "true",
         avoidTolls: query.avoidTolls === "true",
@@ -151,6 +156,7 @@ export function createDirectionsCacheIdentity(
     exclusionsHash,
     lang: routingOptions.lang ?? "en",
     mode: request.travelMode,
+    ...(request.provider && { provider: request.provider }),
     ...(request.operation === "optimize" ? { optimize: true } : {}),
     units: routingOptions.units,
     waypoints: roundWaypoints(request.waypoints),
diff --git a/integrations/routing/index.ts b/integrations/routing/index.ts
index 9394feb11..6357f3a02 100644
--- a/integrations/routing/index.ts
+++ b/integrations/routing/index.ts
@@ -393,6 +393,9 @@ export function setup(ctx: IntegrationContext): void {
     // the generic exclusion contract. Falling back to an engine that ignores
     // these fields would silently return a route through the closed segment.
     let resolvedChain = getRoutingProviders(travelMode, { requireTimeAware });
+    if (request.provider) {
+      resolvedChain = resolvedChain.filter((entry) => entry.integrationId === request.provider);
+    }
     if (hasExclusions) {
       resolvedChain = resolvedChain.filter((e) => e.provider.supportsExclusions === true);
     }
@@ -532,6 +535,9 @@ export function setup(ctx: IntegrationContext): void {
     } = await planDirectionsRequest(ctx, request);
 
     let resolvedChain = getOptimizeProviders(travelMode, { requireTimeAware });
+    if (request.provider) {
+      resolvedChain = resolvedChain.filter((entry) => entry.integrationId === request.provider);
+    }
     // When exclusions are present, only use providers that explicitly honour
     // the generic exclusion contract.
     if (hasExclusions) {
diff --git a/packages/core/src/api/directions.test.ts b/packages/core/src/api/directions.test.ts
index 308c2a478..578cab704 100644
--- a/packages/core/src/api/directions.test.ts
+++ b/packages/core/src/api/directions.test.ts
@@ -5,6 +5,27 @@ import { fetchDirections } from "./directions";
 describe("fetchDirections", () => {
   beforeEach(() => vi.restoreAllMocks());
 
+  it("forwards the provider pin and cancellation signal", async () => {
+    const signal = new AbortController().signal;
+    const spy = vi.spyOn(apiClient, "get").mockResolvedValue({ routes: [] } as never);
+    await fetchDirections(
+      {
+        waypoints: [
+          [1, 2],
+          [3, 4],
+        ],
+        provider: "routing-valhalla",
+      },
+      apiClient,
+      { signal },
+    );
+    expect(spy).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ provider: "routing-valhalla" }),
+      { signal },
+    );
+  });
+
   it("serializes waypoints and forwards options to apiClient.get", async () => {
     const spy = vi.spyOn(apiClient, "get").mockResolvedValue({ routes: [] } as never);
     await fetchDirections({
diff --git a/packages/core/src/api/directions.ts b/packages/core/src/api/directions.ts
index feab13e61..a9a5aaa02 100644
--- a/packages/core/src/api/directions.ts
+++ b/packages/core/src/api/directions.ts
@@ -12,6 +12,8 @@ import { API_ENDPOINTS } from "./endpoints";
 
 export interface FetchDirectionsParams {
   waypoints: LngLat[];
+  /** Pin an enabled routing integration; failure must not change graphs. */
+  provider?: string;
   mode?: TravelMode;
   avoidHighways?: boolean;
   avoidTolls?: boolean;
@@ -35,6 +37,7 @@ export interface FetchDirectionsParams {
 export function fetchDirections(
   {
     waypoints,
+    provider,
     mode = "driving",
     avoidHighways = false,
     avoidTolls = false,
@@ -53,6 +56,7 @@ export function fetchDirections(
     API_ENDPOINTS.directions,
     {
       waypoints: waypointsStr,
+      ...(provider && { provider }),
       mode,
       avoidHighways: String(avoidHighways),
       avoidTolls: String(avoidTolls),
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index d6b88ba51..6c1502b7d 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -183,6 +183,22 @@ export {
   visibleToward,
   windowGeometry,
 } from "./navigation";
+export {
+  type EvaluateRouteStopsInput,
+  evaluateRouteStopDetours,
+  insertRouteStop,
+  ROUTE_STOP_CACHE_MS,
+  ROUTE_STOP_CONCURRENCY,
+  ROUTE_STOP_LIMIT,
+  ROUTE_STOP_PROGRESS_METERS,
+  type RouteStopCandidate,
+  type RouteStopDetour,
+  type RouteStopRequest,
+  type RouteStopWaypointPosition,
+  remainingRouteStopWaypoints,
+  routeStopAccess,
+  routeStopWaypointPositions,
+} from "./navigation/routeStopDetours";
 export type { TransitProgress } from "./navigation/transitProgress";
 export type {
   CameraMode,
diff --git a/packages/core/src/navigation/__tests__/routeStopDetours.test.ts b/packages/core/src/navigation/__tests__/routeStopDetours.test.ts
new file mode 100644
index 000000000..990b575a8
--- /dev/null
+++ b/packages/core/src/navigation/__tests__/routeStopDetours.test.ts
@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import type { LngLat } from "../../types/geometry";
+import type { DirectionsResult, Route } from "../../types/routing";
+import {
+  evaluateRouteStopDetours,
+  insertRouteStop,
+  remainingRouteStopWaypoints,
+  routeStopWaypointPositions,
+} from "../routeStopDetours";
+
+const O: LngLat = [0, 0],
+  W: LngLat = [0.001, 0],
+  D: LngLat = [0.002, 0];
+const urban: LngLat = [0.0012, 0.0001],
+  motorway: LngLat = [0.0014, -0.0001];
+const river: LngLat = [0.0013, 0.0002],
+  restricted: LngLat = [0.0016, 0.0001];
+const route = { geometry: [O, W, D], distance: 2000, duration: 200 } as Route;
+// A directed road graph, specified independently of geometry/projection code.
+// The other carriageway can only be entered by driving to D and returning to W.
+const edges: [LngLat, LngLat, number, number][] = [
+  [O, W, 100, 1000],
+  [W, D, 100, 1000],
+  [W, urban, 10, 50],
+  [urban, W, 10, 50],
+  [D, motorway, 600, 6000],
+  [motorway, W, 600, 6000],
+  [W, river, 300, 2000],
+  [river, W, 300, 2000],
+];
+function graphRoute(points: LngLat[]): DirectionsResult {
+  let duration = 0,
+    distance = 0;
+  for (let i = 1; i < points.length; i++) {
+    const pending = [{ point: points[i - 1], seconds: 0, metres: 0 }];
+    const visited = new Set<string>();
+    let reached = false;
+    while (pending.length) {
+      pending.sort((a, b) => a.seconds - b.seconds);
+      const next = pending.shift()!;
+      const key = next.point.join(",");
+      if (visited.has(key)) continue;
+      visited.add(key);
+      if (key === points[i].join(",")) {
+        duration += next.seconds;
+        distance += next.metres;
+        reached = true;
+        break;
+      }
+      for (const [from, to, seconds, metres] of edges) {
+        if (from.join(",") === key)
+          pending.push({
+            point: to,
+            seconds: next.seconds + seconds,
+            metres: next.metres + metres,
+          });
+      }
+    }
+    if (!reached)
+      return { routes: [], waypoints: points, activeRouteIndex: 0, provider: "routing-fixture" };
+  }
+  return {
+    routes: [{ ...route, duration, distance }],
+    waypoints: points,
+    activeRouteIndex: 0,
+    provider: "routing-fixture",
+  };
+}
+const input = {
+  route: route.geometry,
+  waypoints: [O, W, D],
+  provider: "routing-fixture",
+  signal: new AbortController().signal,
+};
+
+describe("remaining-itinerary stop detours", () => {
+  it("retains a later visit to a waypoint on a route that doubles back", () => {
+    const a: LngLat = [0.02, 0],
+      b: LngLat = [0.01, 0],
+      d: LngLat = [0.03, 0];
+    const geometry: LngLat[] = [O, b, a, b, d];
+    const positions = routeStopWaypointPositions(geometry, [O, a, b, d]);
+    expect(positions[0].alongMeters).toBeCloseTo(2223.9, 0);
+    expect(positions[1].alongMeters).toBeCloseTo(3335.9, 0);
+    expect(remainingRouteStopWaypoints(positions, [0.0135, 0], 1500)).toEqual([
+      [0.0135, 0],
+      a,
+      b,
+      d,
+    ]);
+    expect(insertRouteStop(geometry, [[0.0135, 0], a, b, d], [0.019, 0])).toEqual([
+      [0.0135, 0],
+      [0.019, 0],
+      a,
+      b,
+      d,
+    ]);
+  });
+  it("keeps user waypoint order while inserting at the candidate's route segment", () => {
+    expect(insertRouteStop(route.geometry, [O, W, D], [0.0005, 0.0001])).toEqual([
+      O,
+      [0.0005, 0.0001],
+      W,
+      D,
+    ]);
+    expect(insertRouteStop(route.geometry, [O, W, D], urban)).toEqual([O, W, urban, D]);
+  });
+  it("uses independent road access rather than perpendicular-distance minutes", async () => {
+    const results = await evaluateRouteStopDetours({
+      ...input,
+      candidates: [urban, motorway, river, restricted].map((coordinates, id) => ({
+        id: String(id),
+        coordinates,
+      })),
+      requestRoute: async ({ waypoints }) => graphRoute(waypoints),
+    });
+    expect(
+      results.map((r) =>
+        r.kind === "network" ? [r.kind, r.seconds, r.meters] : [r.kind, undefined, undefined],
+      ),
+    ).toEqual([
+      ["network", 20, 100],
+      ["network", 1300, 13000],
+      ["network", 600, 4000],
+      ["unreachable", undefined, undefined],
+    ]);
+  });
+  it("uses a supplied entrance and retains its identity distinct from the centroid", async () => {
+    const [result] = await evaluateRouteStopDetours({
+      ...input,
+      candidates: [{ id: "entrance", coordinates: restricted, routingEntrance: urban }],
+      requestRoute: async ({ waypoints }) => graphRoute(waypoints),
+    });
+    expect(result).toMatchObject({
+      kind: "network",
+      seconds: 20,
+      access: { kind: "entrance", coordinates: urban },
+    });
+    expect(result.waypoints).toEqual([O, W, urban, D]);
+  });
+  it("labels missing provider evidence and invalid metrics as unknown", async () => {
+    for (const response of [
+      { ...graphRoute([O, W, D]), provider: "other" },
+      { ...graphRoute([O, W, D]), routes: [{ ...route, duration: NaN }] },
+    ]) {
+      const [result] = await evaluateRouteStopDetours({
+        ...input,
+        candidates: [{ id: "u", coordinates: urban }],
+        requestRoute: async () => response,
+      });
+      expect(result.kind).toBe("unknown");
+    }
+  });
+  it("bounds the shortlist and concurrent routing work", async () => {
+    let active = 0,
+      peak = 0,
+      calls = 0;
+    const results = await evaluateRouteStopDetours({
+      ...input,
+      candidates: Array.from({ length: 20 }, (_, id) => ({ id: String(id), coordinates: urban })),
+      requestRoute: async ({ waypoints, provider }) => {
+        expect(provider).toBe("routing-fixture");
+        calls++;
+        peak = Math.max(peak, ++active);
+        await new Promise((resolve) => setTimeout(resolve, 2));
+        active--;
+        return graphRoute(waypoints);
+      },
+    });
+    expect(results).toHaveLength(6);
+    expect(calls).toBe(7);
+    expect(peak).toBe(2);
+  });
+  it("does not issue candidate requests after baseline failure or cancellation", async () => {
+    let calls = 0;
+    const [result] = await evaluateRouteStopDetours({
+      ...input,
+      candidates: [{ id: "u", coordinates: urban }],
+      requestRoute: async () => {
+        calls++;
+        throw new Error("offline");
+      },
+    });
+    expect(result.kind).toBe("unknown");
+    expect(calls).toBe(1);
+    const controller = new AbortController();
+    controller.abort();
+    await expect(
+      evaluateRouteStopDetours({
+        ...input,
+        signal: controller.signal,
+        candidates: [{ id: "u", coordinates: urban }],
+        requestRoute: async () => {
+          calls++;
+          return graphRoute([O, D]);
+        },
+      }),
+    ).rejects.toThrow();
+    expect(calls).toBe(1);
+  });
+});
diff --git a/packages/core/src/navigation/index.ts b/packages/core/src/navigation/index.ts
index 1b0cd1122..b0cd5f56f 100644
--- a/packages/core/src/navigation/index.ts
+++ b/packages/core/src/navigation/index.ts
@@ -191,6 +191,22 @@ export {
   setRouteMatcherCounting,
   snapPreparedRoute,
 } from "./routeMatcher";
+export {
+  type EvaluateRouteStopsInput,
+  evaluateRouteStopDetours,
+  insertRouteStop,
+  ROUTE_STOP_CACHE_MS,
+  ROUTE_STOP_CONCURRENCY,
+  ROUTE_STOP_LIMIT,
+  ROUTE_STOP_PROGRESS_METERS,
+  type RouteStopCandidate,
+  type RouteStopDetour,
+  type RouteStopRequest,
+  type RouteStopWaypointPosition,
+  remainingRouteStopWaypoints,
+  routeStopAccess,
+  routeStopWaypointPositions,
+} from "./routeStopDetours";
 export {
   type AlongRouteOptions,
   type AlongRoutePoi,
diff --git a/packages/core/src/navigation/routeStopDetours.ts b/packages/core/src/navigation/routeStopDetours.ts
new file mode 100644
index 000000000..876b83e4b
--- /dev/null
+++ b/packages/core/src/navigation/routeStopDetours.ts
@@ -0,0 +1,215 @@
+import type { LngLat } from "../types/geometry";
+import type { DirectionsResult, Route } from "../types/routing";
+import { haversineDistance } from "../utils/coordinates";
+import { cumulativeDistances, positionAt } from "./deadReckon";
+import { asRouteMatcher, type RouteMatcherInput, snapPreparedRoute } from "./routeMatcher";
+
+export const ROUTE_STOP_LIMIT = 6;
+export const ROUTE_STOP_CONCURRENCY = 2;
+export const ROUTE_STOP_PROGRESS_METERS = 500;
+export const ROUTE_STOP_CACHE_MS = 60_000;
+
+export interface RouteStopCandidate {
+  id: string;
+  coordinates: LngLat;
+  /** Explicit routable entrance supplied by a source, never inferred from a centroid. */
+  routingEntrance?: LngLat;
+}
+
+interface RouteStopDetourBase {
+  id: string;
+  access: { kind: "entrance" | "coordinate"; coordinates: LngLat };
+  waypoints: LngLat[];
+}
+
+export type RouteStopDetour = RouteStopDetourBase &
+  (
+    | { kind: "network"; meters: number; seconds: number; provider: string }
+    | { kind: "unknown" | "unreachable" }
+  );
+
+export function routeStopAccess(candidate: RouteStopCandidate): RouteStopDetour["access"] {
+  return candidate.routingEntrance
+    ? { kind: "entrance", coordinates: candidate.routingEntrance }
+    : { kind: "coordinate", coordinates: candidate.coordinates };
+}
+
+/** Project onto the future suffix, rather than an earlier visit to the same road. */
+function projectAfter(route: RouteMatcherInput, target: LngLat, fromAlongMeters: number) {
+  const matcher = asRouteMatcher(route);
+  if (fromAlongMeters <= 0) return snapPreparedRoute(matcher, target);
+  const geometry = matcher.geometry;
+  const cumulative = cumulativeDistances(geometry);
+  const total = cumulative.at(-1) ?? 0;
+  const from = Math.min(fromAlongMeters, total);
+  const start = positionAt(geometry, cumulative, from).point;
+  const suffix = [start, ...geometry.filter((_, i) => cumulative[i] > from)];
+  if (suffix.length < 2)
+    return {
+      snapped: start,
+      alongMeters: total,
+      deviationMeters: haversineDistance(start, target),
+      segmentIndex: Math.max(0, geometry.length - 2),
+    };
+  const projected = snapPreparedRoute(asRouteMatcher(suffix), target);
+  return { ...projected, alongMeters: from + projected.alongMeters };
+}
+
+export interface RouteStopWaypointPosition {
+  coordinates: LngLat;
+  alongMeters: number;
+  final: boolean;
+}
+
+/** Resolve waypoint occurrences in itinerary order, including on retraced roads. */
+export function routeStopWaypointPositions(
+  route: RouteMatcherInput,
+  waypoints: LngLat[],
+  fromAlongMeters = 0,
+): RouteStopWaypointPosition[] {
+  const geometry = asRouteMatcher(route).geometry;
+  const total = cumulativeDistances(geometry).at(-1) ?? 0;
+  let cursor = fromAlongMeters;
+  return waypoints.slice(1).map((coordinates, index) => {
+    const final = index === waypoints.length - 2;
+    cursor = final ? total : projectAfter(route, coordinates, cursor).alongMeters;
+    return { coordinates, alongMeters: cursor, final };
+  });
+}
+
+export function remainingRouteStopWaypoints(
+  positions: readonly RouteStopWaypointPosition[],
+  from: LngLat,
+  alongMeters: number,
+): LngLat[] {
+  return [
+    from,
+    ...positions
+      .filter((wp) => wp.final || wp.alongMeters > alongMeters)
+      .map((wp) => wp.coordinates),
+  ];
+}
+
+/** Insert before the next original stop beyond this target, retaining user order. */
+export function insertRouteStop(
+  route: RouteMatcherInput,
+  remaining: LngLat[],
+  target: LngLat,
+  fromAlongMeters = 0,
+): LngLat[] {
+  if (remaining.length < 2) return [];
+  if (remaining.length === 2) return [remaining[0], target, remaining[1]];
+  const along = projectAfter(route, target, fromAlongMeters).alongMeters;
+  const positions = routeStopWaypointPositions(route, remaining, fromAlongMeters);
+  let index = remaining.length - 1;
+  for (let i = 1; i < remaining.length - 1; i++) {
+    if (positions[i - 1].alongMeters > along) {
+      index = i;
+      break;
+    }
+  }
+  return [...remaining.slice(0, index), target, ...remaining.slice(index)];
+}
+
+export interface RouteStopRequest {
+  waypoints: LngLat[];
+  provider?: string;
+  signal: AbortSignal;
+}
+
+export interface EvaluateRouteStopsInput {
+  route: RouteMatcherInput;
+  /** Reference progress on the original route, for repeated road coordinates. */
+  alongMeters?: number;
+  /** Already-pruned itinerary including its reference origin and final destination. */
+  waypoints: LngLat[];
+  candidates: readonly RouteStopCandidate[];
+  provider?: string;
+  signal: AbortSignal;
+  /** The caller closes over the same mode, language and avoid/access options. */
+  requestRoute: (request: RouteStopRequest) => Promise<DirectionsResult>;
+}
+
+function checkAbort(signal: AbortSignal): void {
+  if (!signal.aborted) return;
+  const error = new Error("Route-stop evaluation cancelled");
+  error.name = "AbortError";
+  throw error;
+}
+
+function selectedRoute(result: DirectionsResult): Route | undefined {
+  const route = result.routes?.[result.activeRouteIndex ?? 0];
+  return route &&
+    Number.isFinite(route.duration) &&
+    route.duration >= 0 &&
+    Number.isFinite(route.distance) &&
+    route.distance >= 0
+    ? route
+    : undefined;
+}
+
+/** One baseline plus a bounded, concurrent shortlist; no matrix option assumptions. */
+export async function evaluateRouteStopDetours(
+  input: EvaluateRouteStopsInput,
+): Promise<RouteStopDetour[]> {
+  const { route, waypoints, signal, requestRoute } = input;
+  checkAbort(signal);
+  const results: RouteStopDetour[] = input.candidates
+    .slice(0, ROUTE_STOP_LIMIT)
+    .map((candidate) => {
+      const access = routeStopAccess(candidate);
+      return {
+        id: candidate.id,
+        kind: "unknown",
+        access,
+        waypoints: insertRouteStop(route, waypoints, access.coordinates, input.alongMeters),
+      };
+    });
+  if (results.length === 0 || waypoints.length < 2) return results;
+  let baseline: Route;
+  let provider: string;
+  try {
+    const response = await requestRoute({ waypoints, provider: input.provider, signal });
+    checkAbort(signal);
+    const selected = selectedRoute(response);
+    if (!selected || !response.provider || (input.provider && response.provider !== input.provider))
+      return results;
+    baseline = selected;
+    provider = response.provider;
+  } catch {
+    checkAbort(signal);
+    return results;
+  }
+  let next = 0;
+  const worker = async () => {
+    while (next < results.length) {
+      checkAbort(signal);
+      const index = next++;
+      const result = results[index];
+      try {
+        const response = await requestRoute({ waypoints: result.waypoints, provider, signal });
+        checkAbort(signal);
+        if (response.provider !== provider) continue;
+        const candidate = selectedRoute(response);
+        if (!candidate) {
+          if (Array.isArray(response.routes) && response.routes.length === 0)
+            result.kind = "unreachable";
+          continue;
+        }
+        results[index] = {
+          ...result,
+          kind: "network",
+          provider,
+          seconds: Math.max(0, candidate.duration - baseline.duration),
+          meters: Math.max(0, candidate.distance - baseline.distance),
+        };
+      } catch {
+        checkAbort(signal);
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(ROUTE_STOP_CONCURRENCY, results.length) }, worker),
+  );
+  return results;
+}
diff --git a/packages/core/src/navigation/searchAlongRoute.ts b/packages/core/src/navigation/searchAlongRoute.ts
index df8d39c61..bf6e1427a 100644
--- a/packages/core/src/navigation/searchAlongRoute.ts
+++ b/packages/core/src/navigation/searchAlongRoute.ts
@@ -1,6 +1,7 @@
 import type { BoundingBox, LngLat } from "../types/geometry";
 import { cumulativeDistances, positionAt } from "./deadReckon";
 import { asRouteMatcher, type RouteMatcherInput, snapPreparedRoute } from "./routeMatcher";
+import type { RouteStopDetour } from "./routeStopDetours";
 
 /** A POI projected onto the active route, with an estimated detour. */
 export interface AlongRoutePoi<T> {
@@ -13,6 +14,10 @@ export interface AlongRoutePoi<T> {
   detourMeters: number;
   /** Estimated extra travel time for the detour, seconds. */
   detourSeconds: number;
+  /** Absent means a geometric approximation, never verified road access. */
+  detour?: RouteStopDetour;
+  /** A bounded network comparison is in flight for this candidate. */
+  detourPending?: boolean;
 }
 
 export interface AlongRouteOptions {
diff --git a/packages/core/src/stores/navigationStore.ts b/packages/core/src/stores/navigationStore.ts
index 2422412be..c0930146c 100644
--- a/packages/core/src/stores/navigationStore.ts
+++ b/packages/core/src/stores/navigationStore.ts
@@ -290,7 +290,7 @@ interface NavigationState {
    * persisting the new waypoint list so later reroutes keep the stop. Clears
    * stale progress like a reroute.
    */
-  addStop: (route: Route, waypoints: LngLat[]) => void;
+  addStop: (route: Route, waypoints: LngLat[], provider?: string) => void;
   startTransitNavigation: (itinerary: TripItinerary, replanOptions?: TransitReplanOptions) => void;
   applyTransitProgress: (p: TransitProgress) => void;
   setTransitRerouteNeeded: (v: boolean) => void;
@@ -553,7 +553,7 @@ export const useNavigationStore = create<NavigationState>((set, get) => ({
         fasterRouteSuppressed: false,
       };
     }),
-  addStop: (route, waypoints) => {
+  addStop: (route, waypoints, provider) => {
     clearRoadConditionLeaseTimer();
     set({
       status: "navigating",
@@ -561,6 +561,7 @@ export const useNavigationStore = create<NavigationState>((set, get) => ({
       routes: [route],
       activeRouteIndex: 0,
       destinationWaypoints: waypoints,
+      routeProvider: provider ?? get().routeProvider,
       ...ROUTE_IDENTITY_RESET,
       routeSelectionIntent: "userSelected",
       fasterRouteSuppressed: false,
diff --git a/packages/core/src/types/category.ts b/packages/core/src/types/category.ts
index f0c6f040c..ddc254c5f 100644
--- a/packages/core/src/types/category.ts
+++ b/packages/core/src/types/category.ts
@@ -467,6 +467,8 @@ export interface CategoryPlace {
   gersId?: string;
   name: string;
   coordinates: LngLat;
+  /** Explicit source-supplied routing entrance; ordinary coordinates remain a fallback. */
+  routingEntrance?: LngLat;
   category?: string;
   address?: string;
   phone?: string;
diff --git a/packages/i18n/locales/de.json b/packages/i18n/locales/de.json
index 3adc74d40..79d9b44f1 100644
--- a/packages/i18n/locales/de.json
+++ b/packages/i18n/locales/de.json
@@ -197,6 +197,20 @@
     "rsAdd": "Hinzufügen",
     "rsCancel": "Abbrechen",
     "rsDetour": "+{minutes} Min. Umweg",
+    "rsDetourNetwork": "+{minutes} Min. über das Straßennetz",
+    "rsDetourApproximate": "Etwa +{minutes} Min. · Luftlinien-Schätzung",
+    "rsDetourChecking": "Umweg über das Straßennetz wird geprüft…",
+    "rsDetourUnknown": "Umweg über das Straßennetz nicht verfügbar",
+    "rsDetourUnreachable": "Keine Route zu diesem Stopp",
+    "rsDetourDistance": "+{kilometers} km",
+    "rsDetourCoordinate": "Route zu den Ortskoordinaten; Eingang unbekannt",
+    "rsDetourEntrance": "Route zum bekannten Eingang",
+    "rsPinNetwork": "+{minutes} Min. · Straße",
+    "rsPinApproximate": "~+{minutes} Min.",
+    "rsPinChecking": "Wird geprüft…",
+    "rsPinUnknown": "Umweg unbekannt",
+    "rsPinUnreachable": "Nicht erreichbar",
+    "rsAddFailed": "Stopp konnte nicht hinzugefügt werden. Erneut versuchen.",
     "voicePlatformChange": "Gleiswechsel: Gleis {platform}",
     "voiceScheduleFallback": "Kein GPS-Signal – Führung nach Fahrplan",
     "voicePermissionLost": "Der Standortzugriff wurde deaktiviert, die Führung wurde beendet",
diff --git a/packages/i18n/locales/en.json b/packages/i18n/locales/en.json
index 6872d1060..b9d2d1755 100644
--- a/packages/i18n/locales/en.json
+++ b/packages/i18n/locales/en.json
@@ -197,6 +197,20 @@
     "rsAdd": "Add",
     "rsCancel": "Cancel",
     "rsDetour": "+{minutes} min detour",
+    "rsDetourNetwork": "+{minutes} min by road",
+    "rsDetourApproximate": "About +{minutes} min · straight-line estimate",
+    "rsDetourChecking": "Checking road detour…",
+    "rsDetourUnknown": "Road detour unavailable",
+    "rsDetourUnreachable": "No route to this stop",
+    "rsDetourDistance": "+{kilometers} km",
+    "rsDetourCoordinate": "Routing to place coordinates; entrance unknown",
+    "rsDetourEntrance": "Routing to known entrance",
+    "rsPinNetwork": "+{minutes} min · road",
+    "rsPinApproximate": "~+{minutes} min",
+    "rsPinChecking": "Checking…",
+    "rsPinUnknown": "Unknown detour",
+    "rsPinUnreachable": "Unreachable",
+    "rsAddFailed": "Could not add this stop. Try again.",
     "voicePlatformChange": "Platform change: platform {platform}",
     "voiceScheduleFallback": "No GPS signal — following the timetable",
     "voicePermissionLost": "Location access was turned off, so guidance has stopped",