From 235b0de337f2d0719a32ea789c575c2954c86154 Mon Sep 17 00:00:00 2001
From: Jace Browning <jacebrowning@gmail.com>
Date: Sun, 31 May 2026 19:28:13 -0400
Subject: [PATCH] Show the current location on the map

---
 data/config.json             |   3 +-
 index.html                   |   8 +
 src/bootstrap.mjs            |  17 ++-
 src/shared/data-loader.mjs   |  54 +------
 src/visit/route-planning.mjs |  10 +-
 src/visit/visit.css          |  27 +++-
 src/visit/visit.mjs          | 280 ++++++++++++++++++++++++++++++++++-
 tests/route-planning.spec.js |   6 +-
 tests/visit.spec.js          |  28 ++++
 9 files changed, 367 insertions(+), 66 deletions(-)

diff --git a/data/config.json b/data/config.json
index 9d425d5..b3cddfe 100644
--- a/data/config.json
+++ b/data/config.json
@@ -41,7 +41,8 @@
   "parkingRoutePace": {
     "walkMinutesPerMile": 24,
     "dashMilesPerHour": 12,
-    "dashBoardingWaitMinutes": 5
+    "dashBoardingWaitMinutes": 5,
+    "driveMilesPerHour": 25
   },
   "linkTexts": {
     "viewTransitRoute": "View transit route on Google Maps",
diff --git a/index.html b/index.html
index 4d1340e..6b83fe6 100644
--- a/index.html
+++ b/index.html
@@ -295,6 +295,14 @@ <h2 class="font-semibold text-lg">How each mode works</h2>
         </div>
         <div class="relative min-h-0 flex-1 min-w-0 w-full">
           <div id="parkingAppMap" class="absolute inset-0 min-h-0 w-full"></div>
+          <button
+            type="button"
+            id="parkingLocateBtn"
+            class="parking-map-control-help parking-map-control-locate"
+            aria-label="Show my location on the map"
+            aria-pressed="false"
+            title="Show my location on the map"
+          ></button>
           <button
             type="button"
             id="parkingLegendHelpBtn"
diff --git a/src/bootstrap.mjs b/src/bootstrap.mjs
index f68175e..08af70c 100644
--- a/src/bootstrap.mjs
+++ b/src/bootstrap.mjs
@@ -9,7 +9,6 @@ import {
   haversineMiles,
   roundCoord5,
   MODES_PAGE_EMPTY_MAP_CENTER,
-  FALLBACK_DATA,
   PARKING_PRICE_NOT_LISTED_LABEL,
   getParkingDataViewOverrideSourceFields,
 } from "./shared/data-loader.mjs";
@@ -108,9 +107,7 @@ const DATA_ROUTES_STOP_MAX_MILES_FROM_CENTER = 1.5;
 let validModes = null;
 
 function modesPageOrderedList() {
-  const base = Array.isArray(validModes)
-    ? validModes
-    : FALLBACK_DATA.validModes;
+  const base = Array.isArray(validModes) ? validModes : [];
   return MODES_PAGE_ORDER.filter((m) => base.includes(m));
 }
 
@@ -2404,6 +2401,18 @@ async function init() {
     prepareParkingShellVisibility();
   }
   await loadData();
+  if (!appData) {
+    const appView = document.getElementById("appView");
+    if (appView) {
+      appView.textContent =
+        "Could not load app data. Check the console and refresh.";
+      appView.classList.remove("hidden");
+    }
+    hideDataView();
+    hideModesView();
+    hideParkingView();
+    return;
+  }
   rewriteDeferredDestinationHashIfNeeded();
   if (isParkingRoute()) {
     prepareParkingShellVisibility();
diff --git a/src/shared/data-loader.mjs b/src/shared/data-loader.mjs
index b0743a9..a538678 100644
--- a/src/shared/data-loader.mjs
+++ b/src/shared/data-loader.mjs
@@ -419,58 +419,6 @@ function applyDriveParkingDatasetDisplayNames(parking) {
   parking.categoryNames.airGarageLots = "Private Parking Lots (AirGarage)";
 }
 
-export const FALLBACK_DATA = {
-  validModes: [
-    "drive",
-    "rideshare",
-    "transit",
-    "micromobility",
-    "shuttle",
-    "bike",
-  ],
-  modeLabels: {
-    drive: "driving",
-    rideshare: "Uber/Lyft",
-    transit: "The Rapid",
-    bike: "biking",
-    micromobility: "Lime",
-    walk: "walking",
-    shuttle: "DASH",
-  },
-  costLabels: {
-    drive: "Willing to pay",
-    rideshare: "Willing to pay",
-    transit: "Willing to pay",
-    bike: "Willing to pay",
-    micromobility: "Willing to pay",
-    walk: "Willing to pay",
-    shuttle: "Willing to pay",
-  },
-  defaults: {
-    flexibilityEarlyMins: 15,
-    flexibilityLateMins: 0,
-    people: 1,
-    walkMiles: 1.5,
-    parkingMins: 10,
-    costDollars: 40,
-  },
-  parkingPrivateUnknown: {
-    lotAssumedDollars: 20,
-    garageAssumedDollars: 30,
-    cardCopy:
-      "Typical cost is a planning estimate when no rate is listed—confirm posted prices before you park.",
-  },
-  parkingRoutePace: {
-    walkMinutesPerMile: 24,
-    dashMilesPerHour: 12,
-    dashBoardingWaitMinutes: 5,
-  },
-  destinations: [],
-  linkTexts: {},
-  parking: {},
-  busRoutes: null,
-};
-
 export let appData = null;
 
 /** When true, the venue stays out of browse UI and map placeholder pins until linked (e.g. `#/<slug>` → `#/visit/<slug>`). */
@@ -609,6 +557,6 @@ export async function loadData() {
     };
   } catch (error) {
     console.error("Failed to load data:", error);
-    appData = { ...FALLBACK_DATA };
+    appData = null;
   }
 }
diff --git a/src/visit/route-planning.mjs b/src/visit/route-planning.mjs
index db72094..f4c4d06 100644
--- a/src/visit/route-planning.mjs
+++ b/src/visit/route-planning.mjs
@@ -8,10 +8,12 @@ export const FALLBACK_PARKING_WALK_MINUTES_PER_MILE = 24;
 export const FALLBACK_PARKING_DASH_MILES_PER_HOUR = 12;
 /** Typical wait at the stop before the next DASH shuttle (`#/visit` multimodal time). */
 export const FALLBACK_PARKING_DASH_BOARDING_WAIT_MINUTES = 5;
+/** Urban driving pace for `#/visit` drive-step estimates from the user's location. */
+export const FALLBACK_PARKING_DRIVE_MILES_PER_HOUR = 25;
 
 /**
  * @param {unknown} configObj — `appData.parkingRoutePace` or subset
- * @returns {{ walkMinutesPerMile: number; dashMilesPerHour: number; dashBoardingWaitMinutes: number }}
+ * @returns {{ walkMinutesPerMile: number; dashMilesPerHour: number; dashBoardingWaitMinutes: number; driveMilesPerHour: number }}
  */
 export function resolveParkingRoutePace(configObj) {
   const o = configObj != null && typeof configObj === "object" ? configObj : {};
@@ -20,6 +22,8 @@ export function resolveParkingRoutePace(configObj) {
   const d = /** @type {{ dashMilesPerHour?: unknown }} */ (o).dashMilesPerHour;
   const wait = /** @type {{ dashBoardingWaitMinutes?: unknown }} */ (o)
     .dashBoardingWaitMinutes;
+  const drive = /** @type {{ driveMilesPerHour?: unknown }} */ (o)
+    .driveMilesPerHour;
   return {
     walkMinutesPerMile:
       typeof w === "number" && Number.isFinite(w) && w > 0
@@ -33,6 +37,10 @@ export function resolveParkingRoutePace(configObj) {
       typeof wait === "number" && Number.isFinite(wait) && wait >= 0
         ? wait
         : FALLBACK_PARKING_DASH_BOARDING_WAIT_MINUTES,
+    driveMilesPerHour:
+      typeof drive === "number" && Number.isFinite(drive) && drive > 0
+        ? drive
+        : FALLBACK_PARKING_DRIVE_MILES_PER_HOUR,
   };
 }
 
diff --git a/src/visit/visit.css b/src/visit/visit.css
index f86c167..a1c49d4 100644
--- a/src/visit/visit.css
+++ b/src/visit/visit.css
@@ -72,6 +72,25 @@ main.parking-map-active {
   flex-shrink: 0;
 }
 
+.parking-map-control-locate {
+  top: 48px;
+}
+
+.parking-map-control-locate-icon {
+  width: 23px;
+  height: 23px;
+}
+
+.parking-map-control-locate--active {
+  color: rgb(202 138 4);
+  border-color: rgb(202 138 4);
+}
+
+.parking-map-control-help[aria-busy="true"] {
+  opacity: 0.65;
+  cursor: wait;
+}
+
 /* Parking legend modal — Leaflet fills the Tailwind-sized tile */
 .parking-legend-mini-map.leaflet-container {
   height: 100%;
@@ -187,11 +206,11 @@ main.parking-map-active {
   border: 1px solid transparent;
 }
 
-/* Drive (park here) — green fill + faint neutral edge (slate-300) */
+/* Drive (from your location) — yellow to match the map drive line / steering-wheel pin */
 .parking-route-step-badge--drive {
-  color: rgb(22 101 52);
-  background-color: rgb(220 252 231);
-  border-color: rgb(203 213 225);
+  color: rgb(146 64 14);
+  background-color: rgb(254 249 195);
+  border-color: rgb(250 204 21);
 }
 
 .parking-route-step-badge--walk {
diff --git a/src/visit/visit.mjs b/src/visit/visit.mjs
index 4ec4ce9..7c487ea 100644
--- a/src/visit/visit.mjs
+++ b/src/visit/visit.mjs
@@ -156,6 +156,34 @@ function parkingInstructionDashOnboardMetrics(multimodal) {
   return `${rideM} min ride`;
 }
 
+/** Right-column copy: haversine drive from the user's location (`parkingRoutePace.driveMilesPerHour`). */
+function parkingInstructionDriveEstimateMetrics(
+  fromLat,
+  fromLng,
+  toLat,
+  toLng,
+) {
+  const miles = haversineMiles(fromLat, fromLng, toLat, toLng);
+  if (!Number.isFinite(miles) || miles <= 0) return "";
+  const mph = resolveParkingRoutePace(
+    appData?.parkingRoutePace,
+  ).driveMilesPerHour;
+  const min = Math.max(1, Math.round((miles / mph) * 60));
+  return `${min}+ min drive`;
+}
+
+/** Drive-step badge lines when the user's location is included on the map. */
+function parkingDriveStepMetricsForParkingSpot(parkingLat, parkingLng) {
+  if (!parkingUserLocationIncluded || !parkingUserLocation) return [];
+  const line = parkingInstructionDriveEstimateMetrics(
+    parkingUserLocation.lat,
+    parkingUserLocation.lng,
+    parkingLat,
+    parkingLng,
+  );
+  return line ? [line] : [];
+}
+
 /**
  * One route step: main instruction (left) and optional badge(s) (right).
  * @param {string} mainHtml
@@ -688,6 +716,38 @@ function wavyApproxWalkChordLatLngs(a, b) {
   return out;
 }
 
+/**
+ * Single smooth swoop along a chord — for the drive line from the user's location (not the walk wiggle).
+ * @param {[number, number]} a [lat, lng]
+ * @param {[number, number]} b [lat, lng]
+ * @returns {number[][]}
+ */
+function swoopedDriveChordLatLngs(a, b) {
+  const lat1 = a[0];
+  const lng1 = a[1];
+  const lat2 = b[0];
+  const lng2 = b[1];
+  const dlat = lat2 - lat1;
+  const dlng = lng2 - lng1;
+  const len = Math.sqrt(dlat * dlat + dlng * dlng);
+  if (len < 1e-14) return [a, b];
+  const perpLat = -dlng / len;
+  const perpLng = dlat / len;
+  const chordMi = haversineMiles(lat1, lng1, lat2, lng2);
+  const ampDeg = Math.min(0.0027, Math.max(0.0006, chordMi * 0.0014));
+  const samples = Math.max(24, Math.min(64, Math.round(28 + chordMi * 96)));
+  const out = [];
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const bulge = 4 * t * (1 - t);
+    out.push([
+      lat1 + t * dlat + bulge * ampDeg * perpLat,
+      lng1 + t * dlng + bulge * ampDeg * perpLng,
+    ]);
+  }
+  return out;
+}
+
 /**
  * Symmetric fitBounds padding in px. Leaflet combines TL+BR into one point for
  * getBoundsZoom, so max-zoom uses 2× each axis.
@@ -704,6 +764,12 @@ let parkingSpotsLayerGroup = null;
 let parkingDestinationLayerGroup = null;
 let parkingSpotPickLayerGroup = null;
 let parkingStartFinishLineLayerGroup = null;
+let parkingUserLocationLayerGroup = null;
+/** @type {{ lat: number, lng: number } | null} */
+let parkingUserLocation = null;
+let parkingUserLocationIncluded = false;
+let parkingUserLocationError = "";
+let parkingLocateControlDelegated = false;
 let parkingFilterBarDelegated = false;
 let parkingDestinationSelectDelegated = false;
 let parkingResetDelegated = false;
@@ -2028,6 +2094,22 @@ if (typeof globalThis !== "undefined") {
     parkingTripStepNumbersHashReady;
   globalThis.__markerUsesDashMultimodalForRecommendationForTest =
     markerUsesDashMultimodalForRecommendationFromPool;
+  globalThis.__parkingInstructionDriveEstimateMetricsForTest =
+    parkingInstructionDriveEstimateMetrics;
+  globalThis.__setParkingUserLocationForTest = (lat, lng, included = true) => {
+    if (lat == null || lng == null) {
+      parkingUserLocation = null;
+      parkingUserLocationIncluded = false;
+      return;
+    }
+    parkingUserLocation = { lat: Number(lat), lng: Number(lng) };
+    parkingUserLocationIncluded = included !== false;
+  };
+  globalThis.__setParkingUserLocationIncludedForTest = (included) => {
+    parkingUserLocationIncluded = included === true;
+  };
+  globalThis.__syncParkingRouteInstructionsPanelForTest =
+    syncParkingRouteInstructionsPanel;
 }
 
 /** Session memo — `appData.busRoutes` is static after load; key is `event` | `regular` | `all`. */
@@ -3494,6 +3576,193 @@ function attachParkingDestinationClearButton(marker, name) {
   });
 }
 
+function parkingUserLocationSteeringWheelSvgParts(stroke, width) {
+  return (
+    `<circle cx="16" cy="16" r="10" fill="none" stroke="${stroke}" stroke-width="${width}"/>` +
+    `<circle cx="16" cy="16" r="3" fill="none" stroke="${stroke}" stroke-width="${width}"/>` +
+    `<line x1="16" y1="13" x2="16" y2="6" stroke="${stroke}" stroke-width="${width}" stroke-linecap="round"/>` +
+    `<line x1="18.6" y1="17.5" x2="24.66" y2="21" stroke="${stroke}" stroke-width="${width}" stroke-linecap="round"/>` +
+    `<line x1="13.4" y1="17.5" x2="7.34" y2="21" stroke="${stroke}" stroke-width="${width}" stroke-linecap="round"/>`
+  );
+}
+
+function parkingUserLocationSteeringWheelControlIconSvg() {
+  return (
+    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" ' +
+    'stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" ' +
+    'class="parking-map-control-help-icon parking-map-control-locate-icon" aria-hidden="true">' +
+    '<circle cx="12" cy="12" r="7.5"/>' +
+    '<circle cx="12" cy="12" r="2.25"/>' +
+    '<line x1="12" y1="9.75" x2="12" y2="4.5"/>' +
+    '<line x1="13.95" y1="13.125" x2="18.5" y2="15.75"/>' +
+    '<line x1="10.05" y1="13.125" x2="5.5" y2="15.75"/>' +
+    "</svg>"
+  );
+}
+
+function parkingUserLocationMarkerIcon(L) {
+  const svg =
+    '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32">' +
+    parkingUserLocationSteeringWheelSvgParts("#ffffff", "2.75") +
+    parkingUserLocationSteeringWheelSvgParts("#ca8a04", "1.75") +
+    "</svg>";
+  return L.icon({
+    iconUrl: `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`,
+    iconSize: [32, 32],
+    iconAnchor: [16, 16],
+    popupAnchor: [0, -14],
+  });
+}
+
+function updateParkingLocateButtonState() {
+  const btn = document.getElementById("parkingLocateBtn");
+  if (!btn) return;
+  const on = parkingUserLocationIncluded;
+  const showing = on && parkingUserLocation != null;
+  btn.setAttribute("aria-pressed", on ? "true" : "false");
+  btn.classList.toggle("parking-map-control-locate--active", showing);
+  if (parkingUserLocationError && on) {
+    btn.title = parkingUserLocationError;
+    btn.setAttribute("aria-label", parkingUserLocationError);
+    return;
+  }
+  if (on) {
+    btn.title = "Hide my location on the map";
+    btn.setAttribute("aria-label", "Hide my location on the map");
+    return;
+  }
+  btn.title = "Show my location on the map";
+  btn.setAttribute("aria-label", "Show my location on the map");
+}
+
+function refreshParkingUserLocationOnMap() {
+  if (!parkingMap) return;
+  syncParkingUserLocationMarker(parkingMap);
+  syncParkingRouteInstructionsPanel();
+}
+
+function requestParkingUserLocation(opts) {
+  const prefetch = opts?.prefetch === true;
+  if (typeof navigator === "undefined" || !navigator.geolocation) {
+    if (!prefetch) {
+      parkingUserLocationError = "Location unavailable in this browser";
+      if (parkingUserLocationIncluded) parkingUserLocationIncluded = false;
+      updateParkingLocateButtonState();
+      refreshParkingUserLocationOnMap();
+    }
+    return;
+  }
+  const btn = document.getElementById("parkingLocateBtn");
+  if (!prefetch) btn?.setAttribute("aria-busy", "true");
+  navigator.geolocation.getCurrentPosition(
+    (pos) => {
+      if (!prefetch) btn?.removeAttribute("aria-busy");
+      parkingUserLocationError = "";
+      parkingUserLocation = {
+        lat: pos.coords.latitude,
+        lng: pos.coords.longitude,
+      };
+      if (prefetch) parkingUserLocationIncluded = true;
+      updateParkingLocateButtonState();
+      if (parkingUserLocationIncluded) refreshParkingUserLocationOnMap();
+    },
+    (err) => {
+      if (!prefetch) btn?.removeAttribute("aria-busy");
+      if (!prefetch) {
+        parkingUserLocationError =
+          err?.code === 1
+            ? "Location permission denied"
+            : "Could not get your location";
+        if (parkingUserLocationIncluded) parkingUserLocationIncluded = false;
+        updateParkingLocateButtonState();
+        refreshParkingUserLocationOnMap();
+      }
+    },
+    { enableHighAccuracy: true, timeout: 15000, maximumAge: 60000 },
+  );
+}
+
+function setParkingUserLocationIncluded(next) {
+  const on = next === true;
+  if (on === parkingUserLocationIncluded) return;
+  parkingUserLocationIncluded = on;
+  parkingUserLocationError = "";
+  updateParkingLocateButtonState();
+  if (on && !parkingUserLocation) {
+    requestParkingUserLocation({ prefetch: false });
+    return;
+  }
+  refreshParkingUserLocationOnMap();
+}
+
+function toggleParkingUserLocationIncluded() {
+  setParkingUserLocationIncluded(!parkingUserLocationIncluded);
+}
+
+function resolveParkingUserLocationLineEndLatLng() {
+  const startId = getParkingEffectiveStartSpotId();
+  if (startId) {
+    const start = parseParkingSpotIdToken(startId);
+    if (start) return [start.lat, start.lng];
+  }
+  return getParkingDestinationLatLng();
+}
+
+function syncParkingUserLocationMarker(map) {
+  const L = globalThis.L;
+  if (!map || !L) return;
+
+  if (parkingUserLocationLayerGroup) {
+    try {
+      map.removeLayer(parkingUserLocationLayerGroup);
+    } catch {
+      /* ignore */
+    }
+    parkingUserLocationLayerGroup = null;
+  }
+
+  if (!parkingUserLocationIncluded || !parkingUserLocation) return;
+
+  const { lat, lng } = parkingUserLocation;
+  parkingUserLocationLayerGroup = L.layerGroup().addTo(map);
+
+  const endLl = resolveParkingUserLocationLineEndLatLng();
+  if (endLl) {
+    const curveLl = swoopedDriveChordLatLngs([lat, lng], endLl);
+    const line = L.polyline(curveLl, {
+      color: "#ca8a04",
+      weight: 2.5,
+      opacity: 0.55,
+      lineCap: "round",
+      lineJoin: "round",
+      interactive: false,
+    });
+    line.addTo(parkingUserLocationLayerGroup);
+  }
+
+  const marker = L.marker([lat, lng], {
+    icon: parkingUserLocationMarkerIcon(L),
+    zIndexOffset: 1200,
+  });
+  marker.bindPopup(
+    '<div style="font-size:12px;line-height:1.35"><strong>Your location</strong></div>',
+  );
+  marker.addTo(parkingUserLocationLayerGroup);
+}
+
+function ensureParkingLocateControl() {
+  if (parkingLocateControlDelegated) return;
+  const btn = document.getElementById("parkingLocateBtn");
+  if (!btn) return;
+  parkingLocateControlDelegated = true;
+  btn.innerHTML = parkingUserLocationSteeringWheelControlIconSvg();
+  updateParkingLocateButtonState();
+  btn.addEventListener("click", (e) => {
+    e.preventDefault();
+    toggleParkingUserLocationIncluded();
+  });
+}
+
 function syncParkingDestinationMarker(map) {
   const L = globalThis.L;
   if (!map || !L) return;
@@ -3816,6 +4085,10 @@ function syncParkingRouteInstructionsPanel() {
         )
       : escapeHtml(parkLabel);
   const parkMainHtml = `<strong>Park</strong> at ${parkLabelHtml}`;
+  const driveMetrics = parkingDriveStepMetricsForParkingSpot(
+    start.lat,
+    start.lng,
+  );
 
   const venueMapsHref = parkingGoogleMapsHref(
     destLl[0],
@@ -3856,7 +4129,7 @@ function syncParkingRouteInstructionsPanel() {
       ) < 2e-5;
 
     const steps = [];
-    steps.push(parkingRouteStepLi(parkMainHtml, [], "drive"));
+    steps.push(parkingRouteStepLi(parkMainHtml, driveMetrics, "drive"));
     const w1m = parkingInstructionWalkEstimateMetrics(multimodal.walk1Mi);
     const w2m = parkingInstructionWalkEstimateMetrics(multimodal.walk2Mi);
     const waitM = parkingInstructionDashWaitMetrics(multimodal);
@@ -3948,7 +4221,7 @@ function syncParkingRouteInstructionsPanel() {
   const doorMi = gridWalkMiles(start.lat, start.lng, destLl[0], destLl[1]);
   const doorMetrics = parkingInstructionWalkEstimateMetrics(doorMi);
   const steps = [
-    parkingRouteStepLi(parkMainHtml, [], "drive"),
+    parkingRouteStepLi(parkMainHtml, driveMetrics, "drive"),
     parkingRouteStepLi(
       `<strong>Walk</strong> to ${venueNameHtml}`,
       doorMetrics ? [doorMetrics] : [],
@@ -3969,6 +4242,7 @@ function syncParkingMapOverlays(map, opts) {
   syncParkingSpotPickMarker(map);
   syncParkingStartFinishWalkLine(map);
   syncParkingDestinationMarker(map);
+  syncParkingUserLocationMarker(map);
   syncParkingRouteInstructionsPanel();
   if (doFit) fitParkingMapToAllContent(map);
 }
@@ -4391,6 +4665,7 @@ export function renderParkingView() {
   syncParkingHashStripStartWhenWalkZero();
   ensureParkingResetDelegation();
   ensureParkingLegendModal();
+  ensureParkingLocateControl();
   document.getElementById("parkingMapChrome")?.classList.remove("hidden");
 
   applyParkingRouteLayoutShell();
@@ -4401,6 +4676,7 @@ export function renderParkingView() {
       if (map) {
         map.invalidateSize();
         syncParkingMapOverlays(map);
+        requestParkingUserLocation({ prefetch: true });
       }
       syncParkingLegendModalFromHash();
     });
diff --git a/tests/route-planning.spec.js b/tests/route-planning.spec.js
index 19a9a29..ccc7cda 100644
--- a/tests/route-planning.spec.js
+++ b/tests/route-planning.spec.js
@@ -5,10 +5,11 @@ import {
   FALLBACK_PARKING_WALK_MINUTES_PER_MILE,
   FALLBACK_PARKING_DASH_MILES_PER_HOUR,
   FALLBACK_PARKING_DASH_BOARDING_WAIT_MINUTES,
+  FALLBACK_PARKING_DRIVE_MILES_PER_HOUR,
 } from "../src/visit/route-planning.mjs";
 
 test.describe("Parking route planning", () => {
-  test("defaults match ~2.5 mph walk, 12 mph DASH, and boarding wait", () => {
+  test("defaults match ~2.5 mph walk, 12 mph DASH, boarding wait, and 25 mph drive", () => {
     const pace = resolveParkingRoutePace({});
     expect(pace.walkMinutesPerMile).toBe(
       FALLBACK_PARKING_WALK_MINUTES_PER_MILE,
@@ -17,6 +18,7 @@ test.describe("Parking route planning", () => {
     expect(pace.dashBoardingWaitMinutes).toBe(
       FALLBACK_PARKING_DASH_BOARDING_WAIT_MINUTES,
     );
+    expect(pace.driveMilesPerHour).toBe(FALLBACK_PARKING_DRIVE_MILES_PER_HOUR);
   });
 
   test("prefers walking direct when it takes less time than park + DASH + walk", () => {
@@ -83,10 +85,12 @@ test.describe("Parking route planning", () => {
       walkMinutesPerMile: 18,
       dashMilesPerHour: 10,
       dashBoardingWaitMinutes: 3,
+      driveMilesPerHour: 30,
     });
     expect(pace.walkMinutesPerMile).toBe(18);
     expect(pace.dashMilesPerHour).toBe(10);
     expect(pace.dashBoardingWaitMinutes).toBe(3);
+    expect(pace.driveMilesPerHour).toBe(30);
 
     const r = compareParkingWalkVersusDashMinutes({
       directMi: 1,
diff --git a/tests/visit.spec.js b/tests/visit.spec.js
index ac50145..e1502ea 100644
--- a/tests/visit.spec.js
+++ b/tests/visit.spec.js
@@ -189,10 +189,38 @@ test.describe("Parking map (#/visit)", () => {
       walk: window.appData?.parkingRoutePace?.walkMinutesPerMile,
       dash: window.appData?.parkingRoutePace?.dashMilesPerHour,
       dashWait: window.appData?.parkingRoutePace?.dashBoardingWaitMinutes,
+      drive: window.appData?.parkingRoutePace?.driveMilesPerHour,
     }));
     expect(pace.walk).toBe(24);
     expect(pace.dash).toBe(12);
     expect(pace.dashWait).toBe(5);
+    expect(pace.drive).toBe(25);
+  });
+
+  test("route panel drive badge estimates from user location when known", async ({
+    page,
+  }) => {
+    await page.goto(
+      "/#/visit/devos-performance-hall?walk=0.4&park=public-lot:42.969938,-85.681874",
+    );
+    await waitForParkingData(page);
+    await waitForParkingLeafletMap(page);
+    const panel = page.locator("#parkingRouteInstructionsBody");
+    await expect(panel).toContainText("Park at", { timeout: 15_000 });
+    const driveBadge = panel.locator(".parking-route-step-badge--drive");
+    await page.evaluate(() => {
+      globalThis.__setParkingUserLocationForTest?.(null, null, false);
+      globalThis.__syncParkingRouteInstructionsPanelForTest?.();
+    });
+    await expect(driveBadge).toHaveText("15+ min drive");
+
+    await page.evaluate(() => {
+      globalThis.__setParkingUserLocationForTest?.(42.95, -85.67);
+      globalThis.__syncParkingRouteInstructionsPanelForTest?.();
+    });
+
+    await expect(driveBadge).not.toHaveText("15+ min drive");
+    await expect(driveBadge).toHaveText(/\d+\+ min drive/);
   });
 
   test("preserves destination and category filters in the URL across reload", async ({