How would you design a 'nearby drivers' / proximity search?

// Proximity search: geohash grid index vs full scan, on 10,000 simulated drivers.
const BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
let seed = 42;
function rand() { seed = (seed * 48271) % 2147483647; return seed / 2147483647; }

function encode(lat, lon, precision) {
  let latLo = -90, latHi = 90, lonLo = -180, lonHi = 180;
  let hash = "", bits = 0, ch = 0, even = true;
  while (hash.length < precision) {
    if (even) { const mid = (lonLo + lonHi) / 2; if (lon >= mid) { ch = ch * 2 + 1; lonLo = mid; } else { ch = ch * 2; lonHi = mid; } }
    else { const mid = (latLo + latHi) / 2; if (lat >= mid) { ch = ch * 2 + 1; latLo = mid; } else { ch = ch * 2; latHi = mid; } }
    even = !even;
    if (++bits === 5) { hash += BASE32[ch]; bits = 0; ch = 0; }
  }
  return hash;
}
function cellSize(precision) { // degrees of latitude and longitude covered by one cell
  const lonBits = Math.ceil(precision * 5 / 2), latBits = Math.floor(precision * 5 / 2);
  return [180 / 2 ** latBits, 360 / 2 ** lonBits];
}
function haversineKm(lat1, lon1, lat2, lon2) {
  const r = Math.PI / 180, dLat = (lat2 - lat1) * r, dLon = (lon2 - lon1) * r;
  const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1 * r) * Math.cos(lat2 * r) * Math.sin(dLon / 2) ** 2;
  return 2 * 6371 * Math.asin(Math.sqrt(a));
}
function neighbours(lat, lon, p) { // the cell of (lat, lon) plus the 8 around it
  const [h, w] = cellSize(p), out = [];
  for (const dy of [-1, 0, 1]) for (const dx of [-1, 0, 1]) {
    const c = encode(lat + dy * h, lon + dx * w, p);
    if (!out.includes(c)) out.push(c);
  }
  return out;
}

console.log("geohash(57.64911, 10.40744, 11) = " + encode(57.64911, 10.40744, 11));
console.log("precision  cell height km  cell width km (at lat 37.76)");
for (const p of [4, 5, 6, 7]) {
  const [h, w] = cellSize(p);
  console.log("  " + p + "          " + haversineKm(37.76, -122.44, 37.76 + h, -122.44).toFixed(3) +
    "          " + haversineKm(37.76, -122.44, 37.76, -122.44 + w).toFixed(3));
}

const N = 10000, P = 6, drivers = [], index = new Map();
for (let i = 0; i < N; i++) drivers.push([37.70 + 0.12 * rand(), -122.52 + 0.16 * rand()]);
function add(id) { const c = encode(drivers[id][0], drivers[id][1], P); if (!index.has(c)) index.set(c, []); index.get(c).push(id); return c; }
const cellOf = drivers.map((_, i) => add(i));
console.log("drivers " + N + ", non-empty precision-6 cells " + index.size);

const rider = [37.7600, -122.4400];
console.log("rider cell " + encode(rider[0], rider[1], P));
function search(cells, radiusKm) {
  let checked = 0; const found = [];
  for (const c of cells) for (const id of index.get(c) || []) {
    checked++;
    const d = haversineKm(rider[0], rider[1], drivers[id][0], drivers[id][1]);
    if (d <= radiusKm) found.push([d, id]);
  }
  found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
  return [checked, found];
}
for (const radius of [0.5, 1.5]) {
  const all = [];
  for (let id = 0; id < N; id++) all.push(id);
  let checked = 0; const truth = [];
  for (const id of all) { checked++; const d = haversineKm(rider[0], rider[1], drivers[id][0], drivers[id][1]); if (d <= radius) truth.push([d, id]); }
  truth.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
  const [c1, f1] = search([encode(rider[0], rider[1], P)], radius);
  const [c9, f9] = search(neighbours(rider[0], rider[1], P), radius);
  console.log("radius " + radius.toFixed(1) + " km:");
  console.log("  full scan      checked " + checked + "  found " + truth.length);
  console.log("  own cell only  checked " + c1 + "  found " + f1.length);
  console.log("  cell + 8 nbrs  checked " + c9 + "  found " + f9.length);
  if (radius === 0.5) console.log("  nearest 3: " + f9.slice(0, 3).map(([d, id]) => "driver " + id + " at " + Math.floor(d * 1000) + " m").join(", "));
}

let moved = 0;
for (let id = 0; id < N; id++) {
  drivers[id][0] += (rand() - 0.5) * 0.0018; // up to about 100 m north or south
  drivers[id][1] += (rand() - 0.5) * 0.0022; // up to about 100 m east or west
  const c = encode(drivers[id][0], drivers[id][1], P);
  if (c !== cellOf[id]) { moved++; const list = index.get(cellOf[id]); list.splice(list.indexOf(id), 1); if (!index.has(c)) index.set(c, []); index.get(c).push(id); cellOf[id] = c; }
}
console.log("one 4-second tick: " + N + " position writes, " + moved + " changed cell (" + (100 * moved / N).toFixed(1) + "%)");