How would you design Nearby Friends?

// Nearby Friends: per-user pub/sub channels, receiver-side distance filter, TTL location cache.
let seed = 7;
function rand() { seed = (seed * 48271) % 2147483647; return seed / 2147483647; }
function randInt(n) { return Math.floor(rand() * n); }

const USERS = 2000, FRIENDS_EACH = 20, RADIUS_KM = 5, TTL_S = 600, SERVERS = 4;
const friends = Array.from({ length: USERS }, () => new Set());
for (let u = 0; u < USERS; u++) {
  while (friends[u].size < FRIENDS_EACH) { const v = randInt(USERS); if (v !== u) { friends[u].add(v); friends[v].add(u); } }
}
const online = [], pos = [];
for (let u = 0; u < USERS; u++) { online.push(rand() < 0.3); pos.push([rand() * 40, rand() * 40]); } // a 40 km x 40 km city
let edges = 0; for (const f of friends) edges += f.size;
console.log("users " + USERS + ", avg friends " + (edges / USERS).toFixed(1) + ", online " + online.filter(Boolean).length);

// Location cache: user -> { x, y, expiresAt }, standing for Redis keys with a TTL.
const cache = new Map();
// Pub/sub: channel = user id; subscribers = the WebSocket server of each online friend.
const subs = new Map(); let subscribeCalls = 0;
function connect(u) {
  for (const f of friends[u]) { if (!subs.has(f)) subs.set(f, new Set()); subs.get(f).add(u); subscribeCalls++; }
}
for (let u = 0; u < USERS; u++) if (online[u]) connect(u);
console.log("channel subscriptions opened by the online users: " + subscribeCalls);

function dist(a, b) { return Math.hypot(pos[a][0] - pos[b][0], pos[a][1] - pos[b][1]); }
const perServer = new Array(SERVERS).fill(0);
function publishRound(now) {
  let published = 0, delivered = 0, pushed = 0;
  for (let u = 0; u < USERS; u++) {
    if (!online[u]) continue;
    cache.set(u, { x: pos[u][0], y: pos[u][1], expiresAt: now + TTL_S });
    published++;
    for (const s of subs.get(u) || []) {
      if (!online[s]) continue; // the subscriber has gone; real pub/sub would have dropped it on disconnect
      delivered++; perServer[s % SERVERS]++;
      if (dist(u, s) <= RADIUS_KM) pushed++; // the receiving server filters by distance before pushing to the phone
    }
  }
  return [published, delivered, pushed];
}
const [p, d, s] = publishRound(0);
console.log("one 30 s round: published " + p + ", pub/sub deliveries " + d + ", pushed to phones " + s + " (" + (100 * s / d).toFixed(1) + "% pass the " + RADIUS_KM + " km filter)");
console.log("deliveries per WebSocket server: " + perServer.join(" "));

function nearbyList(u, now) {
  const out = [];
  for (const f of friends[u]) {
    const c = cache.get(f);
    if (!c || c.expiresAt <= now) continue;
    const km = Math.hypot(c.x - pos[u][0], c.y - pos[u][1]);
    if (km <= RADIUS_KM) out.push([km, f]);
  }
  out.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
  return out.map(([km, f]) => "user " + f + " " + km.toFixed(1) + " km");
}
let me = 0; while (!online[me] || nearbyList(me, 0).length < 2) me++;
console.log("user " + me + " opens the app, initial list from the cache: " + nearbyList(me, 0).join(", "));

const friend = [...friends[me]].filter((f) => online[f]).sort((a, b) => dist(me, a) - dist(me, b))[0];
console.log("friend " + friend + " is " + dist(me, friend).toFixed(1) + " km away and walks away 1 km per round:");
for (let r = 1; r <= 4; r++) {
  pos[friend][0] += (pos[friend][0] >= pos[me][0] ? 1 : -1);
  cache.set(friend, { x: pos[friend][0], y: pos[friend][1], expiresAt: r * 30 + TTL_S });
  const km = dist(me, friend);
  console.log("  round " + r + ": " + km.toFixed(1) + " km -> " + (km <= RADIUS_KM ? "pushed, shown" : "dropped by filter"));
}

online[friend] = false; // the friend closes the app: no more publishes, cached location ages out
const last = 4 * 30;
for (const age of [300, 599, 600]) {
  const c = cache.get(friend);
  console.log(age + " s after the last update: " + (c.expiresAt > last + age ? "location still cached" : "location expired, friend leaves every list"));
}