@agentrhq/webcmd 0.2.0 → 0.2.2

package/clis/district/checkout.js

@@ -0,0 +1,278 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+  ArgumentError,
+  AuthRequiredError,
+  CommandExecutionError,
+  EmptyResultError,
+  TimeoutError,
+} from '@agentrhq/webcmd/errors';
+import {
+  BookingClosedError,
+  openSeatMap,
+  profileProbe,
+  refreshShowSession,
+  resolveSeatTarget,
+  validateTimeout,
+  waitFor,
+} from './_lib.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 45;
+
+function parseSeatList(raw) {
+  const seats = String(raw || '')
+    .split(',')
+    .map((seat) => seat.trim().toUpperCase())
+    .filter(Boolean);
+  if (!seats.length) throw new ArgumentError('seats is required, for example --seats I22,I21');
+  if (seats.length > 10) throw new ArgumentError('seats must contain 10 seats or fewer');
+  for (const seat of seats) {
+    if (!/^[A-Z]+[0-9]+$/.test(seat)) throw new ArgumentError(`invalid seat "${seat}"; use row+number like I22`);
+  }
+  if (new Set(seats).size !== seats.length) throw new ArgumentError('seats must not contain duplicates');
+  return seats;
+}
+
+async function dismissSeatDrawer(page) {
+  await page.evaluate(`
+    (() => {
+      const controls = [...document.querySelectorAll('button,[role="button"],[data-testid="close-icon"]')];
+      const continueButton = controls.find((el) => /continue booking/i.test(el.innerText || el.getAttribute('aria-label') || ''));
+      if (continueButton) {
+        continueButton.click();
+        return true;
+      }
+      return false;
+    })()
+  `);
+  await page.wait(0.5);
+}
+
+async function selectRequestedSeats(page, requestedSeats, timeout) {
+  const selected = [];
+  for (const seat of requestedSeats) {
+    const result = await page.evaluate(`
+      (() => {
+        const wanted = ${JSON.stringify(seat)};
+        const parse = (el) => {
+          const aria = el.getAttribute('aria-label') || '';
+          const row = ((aria.match(/row\\s+([^,\\s]+)/i) || [])[1] || '').trim().toUpperCase();
+          const number = (el.querySelector('label')?.innerText || el.innerText || '').replace(/\\s+/g, '').trim();
+          const seatState = /selected/i.test(aria)
+            ? 'selected'
+            : (/available/i.test(aria) ? 'available' : 'unavailable');
+          return { label: row && number ? row + number : '', seatState };
+        };
+        const candidates = [...document.querySelectorAll('#available-seat,[id="selected-seat"] span,[aria-label*="seat"]')];
+        const target = candidates.map((el) => ({ el, parsed: parse(el) })).find((item) => item.parsed.label === wanted);
+        if (!target) return { ok: false, code: 'not_found', message: wanted + ' was not found in the rendered seat map' };
+        if (target.parsed.seatState === 'selected') return { ok: true, action: 'already_selected' };
+        if (target.parsed.seatState !== 'available') return { ok: false, code: 'unavailable', message: wanted + ' is not available' };
+        target.el.click();
+        return { ok: true, action: 'clicked' };
+      })()
+    `);
+    if (!result?.ok) {
+      if (result?.code === 'not_found') throw new EmptyResultError('district checkout', result.message);
+      throw new CommandExecutionError(result?.message || `Could not select ${seat}`);
+    }
+
+    await waitFor(page, 'district checkout seat selection', timeout, `
+      (() => {
+        const wanted = ${JSON.stringify(seat)};
+        const selectedSeats = [...document.querySelectorAll('#selected-seat span,[aria-label^="selected class"]')].map((el) => {
+          const aria = el.getAttribute('aria-label') || '';
+          const row = ((aria.match(/row\\s+([^,\\s]+)/i) || [])[1] || '').trim().toUpperCase();
+          const number = (el.querySelector('label')?.innerText || el.innerText || '').replace(/\\s+/g, '').trim();
+          return row && number ? row + number : '';
+        }).filter(Boolean);
+        const bodyText = document.body ? document.body.innerText.replace(/\\s+/g, ' ').trim().slice(0, 240) : '';
+        return { ok: selectedSeats.includes(wanted), message: bodyText };
+      })()
+    `);
+    selected.push(seat);
+  }
+  return selected;
+}
+
+async function clickProceed(page, timeout) {
+  const result = await page.evaluate(`
+    (() => {
+      const controls = [...document.querySelectorAll('button,[role="button"],a')];
+      const proceed = controls.find((el) => {
+        const text = (el.innerText || '').replace(/\\s+/g, ' ').trim();
+        const label = el.getAttribute('aria-label') || '';
+        return /^Proceed$/i.test(text) || /^Proceed$/i.test(label);
+      });
+      if (!proceed) return { ok: false, message: 'Proceed button was not visible after selecting seats' };
+      proceed.click();
+      return { ok: true };
+    })()
+  `);
+  if (!result?.ok) throw new CommandExecutionError(result?.message || 'Could not click Proceed');
+
+  // District often interposes a food-and-drinks upsell drawer between seat
+  // selection and the review page; skip it while waiting.
+  await waitFor(page, 'district checkout review page', timeout, `
+    (() => {
+      const href = location.href;
+      const text = document.body ? document.body.innerText.replace(/\\s+/g, ' ').trim() : '';
+      if (!/\\/movies\\/order-review\\//.test(href) && /order food and drinks/i.test(text)) {
+        const skip = [...document.querySelectorAll('button,[role="button"]')]
+          .find((el) => /^skip$/i.test((el.innerText || '').trim()));
+        if (skip) skip.click();
+      }
+      return {
+        ok: /\\/movies\\/order-review\\//.test(href) && /Pay now|Payment summary|Review your booking/i.test(text),
+        message: text.slice(0, 240)
+      };
+    })()
+  `);
+}
+
+// The order-review page paints the amounts after the header, so a single-shot
+// read can catch loading skeletons; poll until the payable total is visible.
+async function extractReview(page, target, seats, timeout) {
+  const result = await waitFor(page, 'district checkout payment summary', timeout, `
+    (() => {
+      const showId = ${JSON.stringify(target.showId)};
+      const seats = ${JSON.stringify(seats.join(','))};
+      const lines = (document.body?.innerText || '').split('\\n').map((line) => line.trim()).filter(Boolean);
+      const amountAfter = (label) => {
+        const index = lines.findIndex((line) => line.toLowerCase().includes(label.toLowerCase()));
+        if (index < 0) return '';
+        const amount = lines.slice(index + 1, index + 5).find((line) => /^₹\\s*[0-9,.]+/.test(line));
+        return amount || '';
+      };
+      const movie = [...document.querySelectorAll('h1')]
+        .map((el) => el.innerText.trim())
+        .find((text) => text && !/review your booking/i.test(text)) || '';
+      const ticketCount = lines.find((line) => /^\\d+ tickets?$/i.test(line)) || String(${JSON.stringify(seats.length)});
+      const seatLine = lines.find((line) => / - [A-Z]+\\d+(?:\\s*,\\s*[A-Z]+\\d+)*/.test(line)) || '';
+      const cinema = lines.find((line) => /,/.test(line) && !/^₹/.test(line) && !/District|Booking|GST|approx/i.test(line)) || '';
+      const date = lines.find((line) => /today|tomorrow|\\b\\d{1,2}\\s+[A-Z][a-z]{2}\\b/i.test(line)) || '';
+      const time = lines.find((line) => /\\b\\d{1,2}:\\d{2}\\s*[AP]M\\b.*\\b\\d{1,2}:\\d{2}\\s*[AP]M\\b/i.test(line)) || '';
+      const review = {
+        status: 'ready_for_payment',
+        movie,
+        cinema,
+        date,
+        time,
+        seats: seatLine ? seatLine.replace(/^.*? - /, '').trim() : seats,
+        ticketCount,
+        orderAmount: amountAfter('Order amount'),
+        bookingCharge: amountAfter('Booking charge'),
+        total: amountAfter('To be paid') || amountAfter('TOTAL'),
+        paymentUrl: location.href,
+        showId,
+      };
+      return {
+        ok: Boolean(review.total && review.paymentUrl),
+        message: lines.slice(0, 12).join(' | ').slice(0, 240),
+        review,
+      };
+    })()
+  `);
+  return result.review;
+}
+
+/**
+ * Open the seat map, self-healing once when the show session looks stale:
+ * openSeatMap already fixes stale modals and city-mismatch; on a remaining
+ * closed-booking verdict or a seat map that never renders, one fresh
+ * showtimes lookup re-resolves the same cinema session before giving up.
+ * Only this phase retries — after seats are selected the flow never
+ * restarts, so a held selection is never doubled.
+ */
+async function openSeatMapWithRefresh(page, target, timeout) {
+  try {
+    return await openSeatMap(page, target, timeout);
+  } catch (error) {
+    if (!(error instanceof BookingClosedError) && !(error instanceof TimeoutError)) throw error;
+    const fresh = await refreshShowSession(page, target);
+    if (!fresh) {
+      throw new CommandExecutionError(
+        'District no longer offers this show session; re-run webcmd district showtimes and pick a current show',
+      );
+    }
+    return await openSeatMap(page, fresh, timeout);
+  }
+}
+
+cli({
+  site: 'district',
+  name: 'checkout',
+  access: 'write',
+  description: 'Select District movie seats and stop at the payment handoff page',
+  domain: 'www.district.in',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  defaultWindowMode: 'foreground',
+  siteSession: 'persistent',
+  // Checkout is the most state-sensitive district command: always start on a
+  // clean page so modals/drawers left by earlier commands cannot poison it.
+  freshPage: true,
+  args: [
+    {
+      name: 'show',
+      positional: true,
+      required: true,
+      help: 'District seat-layout URL or showId from district showtimes',
+    },
+    {
+      name: 'seats',
+      required: true,
+      help: 'Comma-separated seat labels to select, e.g. I22,I21',
+    },
+    {
+      name: 'format-id',
+      help: 'District formatId from showtimes; required when show is a showId',
+    },
+    {
+      name: 'content-id',
+      help: 'District content id; required when show is a showId',
+    },
+    {
+      name: 'timeout',
+      type: 'int',
+      default: DEFAULT_TIMEOUT_SECONDS,
+      help: 'Maximum seconds to wait for selection and review page',
+    },
+  ],
+  columns: [
+    'status',
+    'movie',
+    'cinema',
+    'date',
+    'time',
+    'seats',
+    'ticketCount',
+    'orderAmount',
+    'bookingCharge',
+    'total',
+    'paymentUrl',
+    'showId',
+  ],
+  func: async (page, args) => {
+    const seats = parseSeatList(args.seats);
+    const timeout = validateTimeout(args.timeout, { def: DEFAULT_TIMEOUT_SECONDS, min: 10, max: 180 });
+
+    const target = await openSeatMapWithRefresh(page, resolveSeatTarget(args), timeout);
+
+    // Gate on login before touching seats: District bounces Proceed into the
+    // OTP flow, which would waste the whole selection.
+    try {
+      await profileProbe(page);
+    } catch (error) {
+      if (error instanceof AuthRequiredError) {
+        throw new AuthRequiredError('www.district.in', 'District login required before checkout. Run: webcmd district login');
+      }
+      throw error;
+    }
+
+    await dismissSeatDrawer(page);
+    const selected = await selectRequestedSeats(page, seats, timeout);
+    await clickProceed(page, timeout);
+    return extractReview(page, target, selected, timeout);
+  },
+});

package/clis/district/listings.js

@@ -0,0 +1,158 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+
+const BASE = 'https://www.district.in';
+const SECTIONS = new Map([
+  ['home', '/'],
+  ['for-you', '/'],
+  ['movies', '/movies/'],
+  ['events', '/events/'],
+]);
+
+function decodeHtml(value) {
+  return String(value || '')
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, num) => String.fromCodePoint(Number.parseInt(num, 10)))
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function absoluteUrl(href) {
+  try {
+    return new URL(href, BASE).toString();
+  } catch {
+    return '';
+  }
+}
+
+function validateLimit(raw) {
+  const limit = Number(raw ?? 20);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new ArgumentError('limit must be an integer from 1 to 100');
+  }
+  return limit;
+}
+
+function buildUrl(input) {
+  const value = String(input || 'home').trim();
+  const sectionPath = SECTIONS.get(value.toLowerCase());
+  if (sectionPath) return `${BASE}${sectionPath}`;
+
+  if (/^https?:\/\//i.test(value)) {
+    const parsed = new URL(value);
+    if (!/(^|\.)district\.in$/i.test(parsed.hostname)) {
+      throw new ArgumentError('input URL must be on district.in');
+    }
+    return parsed.toString();
+  }
+
+  if (value.startsWith('/')) return absoluteUrl(value);
+
+  throw new ArgumentError('input must be one of home, movies, events, a district.in URL, or a District path');
+}
+
+function inferCategory(url) {
+  if (url.includes('/movies/')) return 'movie';
+  if (url.includes('/events/')) return 'event';
+  if (url.includes('/dining/')) return 'dining';
+  return 'listing';
+}
+
+function isBookableListingUrl(url) {
+  return /\/movies\/[^/]+-movie-tickets-/i.test(url)
+    || /\/events\/[^/]+(?:buy-tickets|ipl-ticket-booking)/i.test(url)
+    || /\/dining\//i.test(url);
+}
+
+function parseListings(html, limit) {
+  const rows = [];
+  const anchorRe = /<a\b[^>]*href=["']([^"']+)["'][^>]*>(?=[\s\S]*?<div[^>]+class=["'][^"']*\bitem-cards\b)[\s\S]*?<\/a>/gi;
+
+  for (const match of html.matchAll(anchorRe)) {
+    const block = match[0];
+    const url = absoluteUrl(match[1]);
+    if (!url || !isBookableListingUrl(url)) continue;
+
+    const titleMatch = block.match(/<h5\b[^>]*>([\s\S]*?)<\/h5>/i);
+    const title = decodeHtml(titleMatch?.[1]);
+    if (!title) continue;
+
+    const spanValues = [...block.matchAll(/<span\b[^>]*>([\s\S]*?)<\/span>/gi)]
+      .map((span) => decodeHtml(span[1]))
+      .filter(Boolean);
+
+    const nonOfferSpans = spanValues.filter((text) => !/\boff\b|cashback|discount|coupon/i.test(text));
+    rows.push({
+      rank: rows.length + 1,
+      title,
+      category: inferCategory(url),
+      date: nonOfferSpans[0] || '',
+      venue: nonOfferSpans[1] || '',
+      price: nonOfferSpans[2] || '',
+      url,
+    });
+
+    if (rows.length >= limit) break;
+  }
+
+  return rows;
+}
+
+cli({
+  site: 'district',
+  name: 'listings',
+  aliases: ['ls'],
+  access: 'read',
+  description: 'List public District by Zomato movies, events, and nearby going-out cards',
+  domain: 'www.district.in',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    {
+      name: 'input',
+      positional: true,
+      required: false,
+      default: 'home',
+      help: 'home, movies, events, a district.in URL, or a District path',
+    },
+    {
+      name: 'limit',
+      type: 'int',
+      default: 20,
+      help: 'Maximum rows to return (1-100)',
+    },
+  ],
+  columns: ['rank', 'title', 'category', 'date', 'venue', 'price', 'url'],
+  func: async (args) => {
+    const limit = validateLimit(args.limit);
+    const url = buildUrl(args.input);
+
+    const resp = await fetch(url, {
+      headers: {
+        Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-IN,en;q=0.9',
+        'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) Chrome Safari/537.36',
+      },
+    });
+
+    if (!resp.ok) {
+      throw new CommandExecutionError(`district listings request failed: HTTP ${resp.status}`);
+    }
+
+    const html = await resp.text();
+    if (!/<html[\s>]/i.test(html)) {
+      throw new CommandExecutionError('district listings expected HTML but received a different response');
+    }
+
+    const rows = parseListings(html, limit);
+    if (!rows.length) {
+      throw new EmptyResultError('district listings', 'No listing cards found on the District page');
+    }
+    return rows;
+  },
+});

package/clis/district/locations.js

@@ -0,0 +1,211 @@
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+
+const BASE = 'https://www.district.in';
+const GUEST_TOKEN = '1212';
+
+function validateQuery(raw) {
+  const query = String(raw || '').trim();
+  if (!query) throw new ArgumentError('query is required');
+  if (query.length > 120) throw new ArgumentError('query must be 120 characters or fewer');
+  return query;
+}
+
+function validateLimit(raw) {
+  const limit = Number(raw ?? 10);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 50) {
+    throw new ArgumentError('limit must be an integer from 1 to 50');
+  }
+  return limit;
+}
+
+function headersFor() {
+  return {
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-IN,en;q=0.9',
+    'Content-Type': 'application/json',
+    Origin: BASE,
+    Referer: `${BASE}/`,
+    'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) Chrome Safari/537.36',
+    'x-guest-token': GUEST_TOKEN,
+    'x-app-type': 'ed_web',
+    'x-client-id': 'district-web',
+    'x-app-version': '11.11.1',
+    'x-device-id': crypto.randomUUID(),
+  };
+}
+
+async function fetchLocationSearch(body) {
+  const resp = await fetch(`${BASE}/gw/web/get_location_search`, {
+    method: 'POST',
+    headers: headersFor(),
+    body: JSON.stringify(body),
+  });
+  if (!resp.ok) throw new CommandExecutionError(`district locations request failed: HTTP ${resp.status}`);
+
+  const data = await resp.json();
+  if (data?.status?.status === 'STATUS_FAILURE') {
+    throw new CommandExecutionError(data.status.message || 'district locations request failed');
+  }
+  return data;
+}
+
+function normalize(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function distanceKm(aLat, aLng, bLat, bLng) {
+  const toRad = (deg) => (deg * Math.PI) / 180;
+  const r = 6371;
+  const dLat = toRad(bLat - aLat);
+  const dLng = toRad(bLng - aLng);
+  const lat1 = toRad(aLat);
+  const lat2 = toRad(bLat);
+  const a = Math.sin(dLat / 2) ** 2
+    + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+  return 2 * r * Math.asin(Math.sqrt(a));
+}
+
+function kindFor(entity) {
+  const type = String(entity.entity_type || '');
+  if (type.includes('CITY')) return 'city';
+  if (type.includes('GOOGLE_PLACE')) return 'google_place';
+  if (type.includes('POI')) return String(entity.poi_type || 'poi').trim().toLowerCase() || 'poi';
+  return 'location';
+}
+
+function cityRecordFor(entity, cities) {
+  const entityName = normalize(entity.title || entity.fullname);
+  const entityState = normalize(String(entity.subtitle || '').split(',').at(-1));
+
+  const exact = cities.find((city) => {
+    const names = [
+      city.city_name,
+      city.cleaned_city_name,
+      city.city_key,
+    ].map(normalize);
+    return names.includes(entityName)
+      || (normalize(city.city_name) === entityName && (!entityState || normalize(city.state_name) === entityState));
+  });
+  if (exact) return exact;
+
+  const lat = Number(entity.lat);
+  const lng = Number(entity.long);
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
+
+  let nearest = null;
+  for (const city of cities) {
+    const cityLat = Number(city.city_lat);
+    const cityLng = Number(city.city_long);
+    if (!Number.isFinite(cityLat) || !Number.isFinite(cityLng)) continue;
+    const km = distanceKm(lat, lng, cityLat, cityLng);
+    if (!nearest || km < nearest.km) nearest = { city, km };
+  }
+  return nearest && nearest.km <= 80 ? nearest.city : null;
+}
+
+function scoreFor(entity, query, index) {
+  const q = normalize(query);
+  const title = normalize(entity.title);
+  const full = normalize(`${entity.title} ${entity.subtitle} ${entity.fullname}`);
+  let score = 1000 - index;
+  if (title === q) score += 5000;
+  else if (title.startsWith(q)) score += 3000;
+  else if (full.includes(q)) score += 1000;
+  if (kindFor(entity) === 'city') score += 600;
+  return score;
+}
+
+function rowFor(entity, index, query, cities, primaryCity) {
+  const city = cityRecordFor(entity, cities) || {};
+  const kind = kindFor(entity);
+  const placeId = String(entity.google_place_id || entity.poi_id || '');
+  const dist = Number(entity.distance);
+  const samePrimaryCity = primaryCity?.city_id && city.city_id === primaryCity.city_id;
+  return {
+    score: scoreFor(entity, query, index) + (samePrimaryCity ? 450 : 0),
+    row: {
+      rank: index + 1,
+      name: String(entity.title || entity.fullname || '').trim(),
+      kind,
+      city: String(city.city_name || (kind === 'city' ? entity.title : '') || '').trim(),
+      state: String(city.state_name || '').trim(),
+      cityKey: String(city.city_key || '').trim(),
+      cityId: String(city.city_id || '').trim(),
+      placeId,
+      lat: Number(entity.lat || 0),
+      lng: Number(entity.long || 0),
+      distanceKm: Number.isFinite(dist) ? Number((dist / 1000).toFixed(1)) : 0,
+      source: 'district_location_search',
+    },
+  };
+}
+
+cli({
+  site: 'district',
+  name: 'locations',
+  aliases: ['location-search'],
+  access: 'read',
+  description: 'Search District-supported cities, areas, malls, and places for booking filters',
+  domain: 'www.district.in',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    {
+      name: 'query',
+      positional: true,
+      required: true,
+      help: 'City, area, mall, or locality, for example "bangalore" or "indiranagar"',
+    },
+    {
+      name: 'limit',
+      type: 'int',
+      default: 10,
+      help: 'Maximum location rows to return (1-50)',
+    },
+  ],
+  columns: [
+    'rank',
+    'name',
+    'kind',
+    'city',
+    'state',
+    'cityKey',
+    'cityId',
+    'placeId',
+    'lat',
+    'lng',
+    'distanceKm',
+    'source',
+  ],
+  func: async (args) => {
+    const query = validateQuery(args.query);
+    const limit = validateLimit(args.limit);
+    const [searchData, allData] = await Promise.all([
+      fetchLocationSearch({ searched_text: query }),
+      fetchLocationSearch({}),
+    ]);
+
+    const cities = Array.isArray(allData?.cities) ? allData.cities : [];
+    const entities = Array.isArray(searchData?.entities) ? searchData.entities : [];
+    if (!entities.length) throw new EmptyResultError('district locations', `No locations found for "${query}"`);
+
+    const queryNorm = normalize(query);
+    const primaryCity = entities
+      .filter((entity) => kindFor(entity) === 'city')
+      .map((entity) => cityRecordFor(entity, cities))
+      .find((city) => city && [city.city_name, city.cleaned_city_name, city.city_key].map(normalize).includes(queryNorm));
+
+    return entities
+      .map((entity, index) => rowFor(entity, index, query, cities, primaryCity))
+      .filter((item) => item.row.name && Number.isFinite(item.row.lat) && Number.isFinite(item.row.lng))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit)
+      .map((item, index) => ({ ...item.row, rank: index + 1 }));
+  },
+});