@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/search/categories.js

@@ -0,0 +1,179 @@
+const c = (label, none, singular, plural, filter, notBefore) => ({ label, none, singular, plural, filter, ...(notBefore ? { notBefore } : {}) });
+export const categoryByLabel = (label) => CATEGORIES.find((k) => k.label === label) ?? null;
+export const CATEGORIES = [
+    c('hôtels', 'Aucun hôtel trouvé', ['hotel'], ['hotels'], '["tourism"="hotel"]'),
+    c('auberges de jeunesse', 'Aucune auberge de jeunesse trouvée', ['auberge de jeunesse'], ['auberges de jeunesse'], '["tourism"="hostel"]'),
+    c('campings', 'Aucun camping trouvé', ['camping'], ['campings'], '["tourism"="camp_site"]'),
+    c('restaurants', 'Aucun restaurant trouvé', ['restaurant', 'resto'], ['restaurants', 'restos'], '["amenity"="restaurant"]'),
+    c('bars', 'Aucun bar trouvé', ['bar', 'pub'], ['bars', 'pubs'], '["amenity"~"^(bar|pub)$"]'),
+    c('cafés', 'Aucun café trouvé', ['cafe'], ['cafes'], '["amenity"="cafe"]'),
+    c('boulangeries', 'Aucune boulangerie trouvée', ['boulangerie'], ['boulangeries'], '["shop"="bakery"]'),
+    c('supermarchés', 'Aucun supermarché trouvé', ['supermarche'], ['supermarches'], '["shop"="supermarket"]'),
+    c('pharmacies', 'Aucune pharmacie trouvée', ['pharmacie'], ['pharmacies'], '["amenity"="pharmacy"]'),
+    c('hôpitaux', 'Aucun hôpital trouvé', ['hopital'], ['hopitaux'], '["amenity"="hospital"]'),
+    c('cliniques', 'Aucune clinique trouvée', ['clinique'], ['cliniques'], '["amenity"="clinic"]'),
+    c('médecins', 'Aucun médecin trouvé', ['medecin'], ['medecins'], '["amenity"="doctors"]'),
+    c('dentistes', 'Aucun dentiste trouvé', ['dentiste'], ['dentistes'], '["amenity"="dentist"]'),
+    c('banques', 'Aucune banque trouvée', ['banque'], ['banques'], '["amenity"="bank"]'),
+    c('distributeurs de billets', 'Aucun distributeur de billets trouvé', ['distributeur de billets', 'distributeur'], ['distributeurs de billets', 'distributeurs'], '["amenity"="atm"]'),
+    c('stations-service', 'Aucune station-service trouvée', ['station service', 'station essence'], ['stations service', 'stations essence'], '["amenity"="fuel"]'),
+    c('bornes de recharge', 'Aucune borne de recharge trouvée', ['borne de recharge'], ['bornes de recharge'], '["amenity"="charging_station"]'),
+    c('parkings', 'Aucun parking trouvé', ['parking'], ['parkings'], '["amenity"="parking"]'),
+    c('gares', 'Aucune gare trouvée', ['gare'], ['gares'], '["railway"="station"]'),
+    c('musées', 'Aucun musée trouvé', ['musee'], ['musees'], '["tourism"="museum"]'),
+    c('cinémas', 'Aucun cinéma trouvé', ['cinema'], ['cinemas'], '["amenity"="cinema"]'),
+    c('théâtres', 'Aucun théâtre trouvé', ['theatre'], ['theatres'], '["amenity"="theatre"]'),
+    c('bibliothèques', 'Aucune bibliothèque trouvée', ['bibliotheque'], ['bibliotheques'], '["amenity"="library"]'),
+    c('écoles', 'Aucune école trouvée', ['ecole'], ['ecoles'], '["amenity"="school"]'),
+    c('universités', 'Aucune université trouvée', ['universite'], ['universites'], '["amenity"="university"]'),
+    c('parcs', 'Aucun parc trouvé', ['parc'], ['parcs'], '["leisure"="park"]', ['informatique', 'informatiques', 'de machines', 'de serveurs', 'de postes', 'reseau', 'materiel']),
+    c('salles de sport', 'Aucune salle de sport trouvée', ['salle de sport'], ['salles de sport'], '["leisure"="fitness_centre"]'),
+    c('commissariats', 'Aucun commissariat trouvé', ['commissariat', 'gendarmerie'], ['commissariats', 'gendarmeries'], '["amenity"="police"]'),
+    c('bureaux de poste', 'Aucun bureau de poste trouvé', ['bureau de poste'], ['bureaux de poste'], '["amenity"="post_office"]'),
+    c('mairies', 'Aucune mairie trouvée', ['mairie'], ['mairies'], '["amenity"="townhall"]'),
+    c('églises', 'Aucune église trouvée', ['eglise'], ['eglises'], '["amenity"="place_of_worship"]["religion"="christian"]'),
+    c('laveries', 'Aucune laverie trouvée', ['laverie'], ['laveries'], '["shop"="laundry"]'),
+];
+/** Sans accents ni majuscules, apostrophes et tirets changés en espaces : « l'hôtel » donne « l hotel ». */
+const norm = (s) => s
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+const tokens = (s) => (norm(s) ? norm(s).split(' ') : []);
+const DEFINITE = new Set(['le', 'la', 'l']);
+function find(words) {
+    for (let i = 0; i < words.length; i++) {
+        for (const category of CATEGORIES) {
+            // Les formes longues d'abord : « distributeurs de billets » avant « distributeurs »
+            const forms = [...category.plural.map((f) => ({ f, plural: true })), ...category.singular.map((f) => ({ f, plural: false }))].sort((a, b) => b.f.length - a.f.length);
+            for (const { f, plural } of forms) {
+                const parts = f.split(' ');
+                if (parts.every((p, k) => words[i + k] === p)) {
+                    const end = i + parts.length;
+                    const next = words.slice(end, end + 2).join(' ');
+                    if (category.notBefore?.some((n) => next === n || next.startsWith(`${n} `)))
+                        continue;
+                    return { category, plural, start: i, end };
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Le mot qui suit la catégorie dans le texte d'origine commence par une majuscule : un nom propre (« hôtel Lutetia »). */
+function namedAfter(text, found) {
+    const original = text.replace(/[’']/g, ' ').split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+    const next = original[found.end];
+    return next !== undefined && /^\p{Lu}/u.test(next);
+}
+/**
+ * La catégorie d'une demande de plusieurs lieux, ou null pour un lieu seul ou une demande sans lieu.
+ * `text` : la demande de l'utilisateur. `query` : la requête du classement, qui porte la catégorie dans une relance
+ * (« et à Lyon ? » après « tous les hôtels de Paris » donne « hôtels Lyon »).
+ */
+export function detectMany(text, query) {
+    const words = tokens(text);
+    const inText = find(words);
+    if (inText) {
+        if (inText.plural)
+            return inText.category;
+        // « la gare d'Amiens », « l'hôtel Lutetia » : un lieu précis. « hôtel Lutetia » aussi.
+        if (inText.start > 0 && DEFINITE.has(words[inText.start - 1] ?? ''))
+            return null;
+        if (namedAfter(text, inText))
+            return null;
+        return inText.category;
+    }
+    const inQuery = find(tokens(query));
+    return inQuery?.plural ? inQuery.category : null;
+}
+/** Mots qui disent ce qu'on veut de la zone, pas la zone elle-même. */
+const ANCHOR_NOISE = new Set([
+    ...['adresse', 'adresses', 'carte', 'plan', 'itineraire', 'localisation', 'emplacement', 'coordonnees', 'gps', 'trouver', 'situe', 'situes', 'ou', 'acces'],
+    ...['tous', 'toutes', 'tout', 'liste', 'quel', 'quels', 'quelle', 'quelles', 'meilleur', 'meilleurs', 'meilleure', 'meilleures', 'top'],
+    ...['bon', 'bons', 'bonne', 'bonnes', 'pas', 'cher', 'chers', 'chere', 'cheres', 'ouvert', 'ouverts', 'ouverte', 'ouvertes', 'garde'],
+    ...['proche', 'proches', 'pres', 'autour', 'cote', 'alentours', 'proximite', 'loin', 'non', 'avis', 'prix', 'luxe', 'etoiles', 'sympa', 'sympas'],
+]);
+/**
+ * Un mot de la catégorie ou de service. « stations-service » compte, mot par mot. Les mots courts des formes (« de »
+ * dans « distributeur de billets ») ne comptent pas : « Saint-Jean de Lyon » les garde.
+ */
+function serviceWord(word, category) {
+    const forms = new Set([...category.singular, ...category.plural].flatMap((f) => f.split(' ')).filter((p) => p.length > 2));
+    const parts = tokens(word);
+    return parts.length > 0 && parts.every((p) => forms.has(p) || ANCHOR_NOISE.has(p));
+}
+/** Mots de liaison retirés aux bords d'une zone : « de la Tour Eiffel » donne « Tour Eiffel ». */
+const EDGE = new Set(['de', 'du', 'des', 'la', 'le', 'les', 'l', 'd', 'a', 'au', 'aux', 'en', 'dans', 'sur', 'pour', 'et', 'vers']);
+/** Ce qui reste d'un texte sans la catégorie, les mots de service ni les mots de liaison des bords. */
+function withoutCategory(text, category) {
+    const kept = text
+        .replace(/[’']/g, "' ")
+        .split(/\s+/)
+        .filter((w) => norm(w) !== '' && !serviceWord(w, category));
+    while (kept.length > 0 && EDGE.has(norm(kept[0] ?? '')))
+        kept.shift();
+    while (kept.length > 0 && EDGE.has(norm(kept.at(-1) ?? '')))
+        kept.pop();
+    // La ponctuation n'est retirée qu'aux bords : la virgule de « Saint-Jean de Lyon, Lyon » sert à toPlace
+    return kept
+        .join(' ')
+        .replace(/' /g, "'")
+        .replace(/^[\s,.;:!?«»"()]+|[\s,.;:!?«»"()]+$/g, '');
+}
+/**
+ * Où chercher la zone, dans l'ordre : la requête sans la catégorie, le lieu du classement, puis les noms propres de la
+ * requête. Une zone sans majuscule n'est retenue que si Photon y trouve une zone administrative (anchorAccepted).
+ */
+export function anchorCandidates(query, place, category) {
+    const proper = query
+        .replace(/[’']/g, ' ')
+        .split(/\s+/)
+        .filter((w) => /^\p{Lu}/u.test(w) && !serviceWord(w, category))
+        .join(' ');
+    const seen = new Set();
+    return [withoutCategory(query, category), place ? withoutCategory(place, category) : '', proper].filter((q) => {
+        const key = norm(q);
+        if (!key || seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * La zone trouvée pour un candidat est-elle crédible ? Un nom propre suffit (« Tour Eiffel », « Lyon »). Sans majuscule
+ * (le modèle écrit parfois « musées de paris »), il faut une relation OpenStreetMap, une ville ou un quartier :
+ * « meilleures écoles de cybersécurité » ne doit pas devenir une carte autour d'un lieu nommé « cybersécurité ».
+ */
+export function anchorAccepted(candidate, found) {
+    return /\p{Lu}/u.test(candidate) || (found.osm ?? '').startsWith('relation/');
+}
+/** Rayon autour d'un lieu sans surface (un bâtiment, une station) : 1 km. */
+export const AROUND_RADIUS = 1000;
+/** Au-delà de cette diagonale, la zone est trop grande pour y lister des lieux (une région, un pays). */
+export const MAX_ZONE_KM = 100;
+/** En dessous, un lieu avec une surface (un parc, un site) se traite comme un point. */
+const MIN_AREA_KM = 1.5;
+/** Diagonale d'une boîte [sud, nord, ouest, est], en kilomètres. */
+export function diagonalKm([south, north, west, east]) {
+    const rad = Math.PI / 180;
+    const a = Math.sin(((north - south) * rad) / 2) ** 2 + Math.cos(south * rad) * Math.cos(north * rad) * Math.sin(((east - west) * rad) / 2) ** 2;
+    return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+/**
+ * La zone d'un lieu trouvé par Photon : une ville (relation OpenStreetMap) se cherche dans ses limites, un grand chemin
+ * fermé dans sa boîte, un bâtiment ou un point dans un rayon de 1 km. null : trop grand (plus de 100 km de diagonale).
+ */
+export function zoneOf(place) {
+    const size = place.bbox ? diagonalKm(place.bbox) : 0;
+    if (size > MAX_ZONE_KM)
+        return null;
+    const [type, id] = (place.osm ?? '').split('/');
+    if (size >= MIN_AREA_KM && type === 'relation' && id)
+        return { kind: 'area', id: 3_600_000_000 + Number(id), bbox: place.bbox };
+    if (size >= MIN_AREA_KM && place.bbox)
+        return { kind: 'bbox', bbox: place.bbox };
+    return { kind: 'around', lat: place.lat, lon: place.lon, radius: AROUND_RADIUS };
+}

package/lib/server/search/fiche.js

@@ -0,0 +1,326 @@
+/**
+ * La fiche d'un lieu, ouverte d'un clic sur son point : GET /api/map/card et GET /api/map/image/:id
+ * (.equipe/recherche/CONTRAT-LIEUX.md).
+ *
+ * 1. Les étiquettes OpenStreetMap du lieu (Overpass) : son site, son article Wikipédia ou son élément Wikidata.
+ * 2. Un article Wikipédia : son résumé et sa photo.
+ * 3. Sinon, ou pour ce qui manque : SearXNG, avec « nom zone ». L'extrait du site du lieu s'il est dans les résultats,
+ *    sinon du premier résultat dont le titre porte la majorité des mots du nom. Même règle pour l'image.
+ *
+ * Les images passent par le serveur, comme les tuiles : la page ne contacte que lui. Il ne télécharge que les adresses
+ * qu'il a lui-même choisies (id opaque), en https, sur une liste fermée d'hôtes de vignettes, sans redirection, 2 Mo au
+ * plus, et seulement des jpeg, png, webp ou gif.
+ */
+import crypto from 'node:crypto';
+import { VERSION } from '../config.js';
+import { AppError, badRequest, describeError } from '../errors.js';
+import { cut, hasMajority, placeWords } from './searxng.js';
+const USER_AGENT = `Promethee/${VERSION} (console locale, fiches des lieux)`;
+const WIKI_TIMEOUT_MS = 8_000;
+const IMAGE_TIMEOUT_MS = 8_000;
+export const MAX_IMAGE_BYTES = 2 * 1024 * 1024;
+const IMAGE_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
+/** Les hôtes des vignettes : Wikimédia, Bing et Brave (ce que rend SearXNG ici). */
+const IMAGE_HOSTS = [/^upload\.wikimedia\.org$/, /^thumb\.wikimedia\.org$/, /^tse?\d{0,2}\.mm\.bing\.net$/, /^th\.bing\.com$/, /^imgs\.search\.brave\.com$/];
+const TAGS_TIMEOUT_MS = 6_000;
+const MAX_CARDS = 300;
+const MAX_IMAGES = 500;
+const MAX_IMAGE_BYTES_KEPT = 100;
+const clean = (s) => (typeof s === 'string' ? s.replace(/\s+/g, ' ').trim() : '');
+/** Une vignette que le serveur accepte de télécharger. */
+export function imageAllowed(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === 'https:' && !u.username && !u.password && u.port === '' && IMAGE_HOSTS.some((h) => h.test(u.hostname));
+    }
+    catch {
+        return false;
+    }
+}
+const DATA_IMAGE = /^data:(image\/(?:jpeg|png|webp|gif));base64,([A-Za-z0-9+/=]{16,700000})$/;
+/** Le domaine d'une adresse, sans « www. », ou null. */
+export function hostOf(url) {
+    try {
+        return new URL(url).hostname.replace(/^www\./, '') || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Le site d'un lieu d'après OpenStreetMap, s'il est en http(s). */
+export function safeWebsite(value) {
+    const v = clean(value);
+    try {
+        const u = new URL(v);
+        return (u.protocol === 'https:' || u.protocol === 'http:') && !u.username && !u.password ? u.toString() : null;
+    }
+    catch {
+        return null;
+    }
+}
+const ENGINE_NAMES = {
+    google: 'Google',
+    bing: 'Bing',
+    duckduckgo: 'DuckDuckGo',
+    brave: 'Brave',
+    qwant: 'Qwant',
+    startpage: 'Startpage',
+    wikipedia: 'Wikipédia',
+    wikicommons: 'Wikimedia Commons',
+    mojeek: 'Mojeek',
+    yahoo: 'Yahoo',
+    pinterest: 'Pinterest',
+};
+/** Le moteur qui a donné le résultat, lisible : « bing images » donne « Bing », « google cse » donne « Google ». */
+export function engineName(engines) {
+    const first = engines[0];
+    if (!first)
+        return null;
+    return ENGINE_NAMES[first.toLowerCase().split(/[\s.]/)[0] ?? ''] ?? first;
+}
+/**
+ * Le titre porte le nom du lieu : tous ses mots significatifs, ou tous sauf un au-delà de trois. Plus strict que la
+ * majorité des lieux de carte (essai réel : « Pharmacie Saint-Jean, Lyon » prenait une herboristerie Saint-Jean).
+ */
+export function namesPlace(name, text) {
+    const words = placeWords(name);
+    if (words.length === 0)
+        return false;
+    const own = new Set(placeWords(text));
+    const found = words.filter((w) => own.has(w)).length;
+    return found >= (words.length <= 3 ? words.length : words.length - 1);
+}
+/** L'extrait qui décrit le lieu : celui de son site s'il est dans les résultats, sinon le premier dont le titre porte son nom. */
+export function pickDescription(sources, name, website) {
+    const site = website ? hostOf(website) : null;
+    const usable = sources.filter((s) => s.snippet);
+    const hit = (site ? usable.find((s) => hostOf(s.url) === site) : undefined) ?? usable.find((s) => namesPlace(name, s.title));
+    if (!hit)
+        return null;
+    return { text: hit.snippet, source: { label: hostOf(hit.url) ?? hit.url, url: hit.url, via: engineName(hit.engines) } };
+}
+/**
+ * L'image du lieu, parmi les vignettes que le serveur sait télécharger : d'abord celle d'un site de confiance (le site du
+ * lieu, celui de l'extrait), sinon la première dont le titre porte le nom et, s'il y a une zone, la ville (essai réel : une
+ * « Pharmacie Saint-Jean » d'Orléans pour celle de Lyon).
+ */
+export function pickImage(hits, name, zone, trusted) {
+    const hosts = new Set(trusted.filter((h) => Boolean(h)));
+    const zoneWords = placeWords(zone);
+    const usable = hits.filter((h) => imageAllowed(h.thumbnail) || DATA_IMAGE.test(h.thumbnail));
+    const hit = usable.find((h) => hosts.has(hostOf(h.url) ?? '')) ??
+        usable.find((h) => namesPlace(name, h.title) && (zoneWords.length === 0 || hasMajority(zoneWords, `${h.title} ${h.url.replace(/[^a-z0-9]+/gi, ' ')}`)));
+    if (!hit)
+        return null;
+    return { url: hit.thumbnail, source: { label: hostOf(hit.url) ?? hit.url, url: hit.url, via: engineName(hit.engines) } };
+}
+/** Un résultat web qui est l'article Wikipédia du lieu : sa langue et son titre, pour lire son résumé. */
+export function wikipediaArticle(sources, name) {
+    for (const s of sources) {
+        const m = /^https:\/\/(fr|en)\.(?:m\.)?wikipedia\.org\/wiki\/([^?#]+)$/.exec(s.url);
+        if (!m?.[1] || !m[2])
+            continue;
+        let title;
+        try {
+            title = decodeURIComponent(m[2]).replace(/_/g, ' ');
+        }
+        catch {
+            continue;
+        }
+        if (namesPlace(name, title))
+            return { lang: m[1], title };
+    }
+    return null;
+}
+/** Les paramètres de GET /api/map/card, vérifiés. */
+export function parseCardRequest(params) {
+    const name = clean(params.get('name'));
+    const zone = clean(params.get('zone'));
+    const osm = clean(params.get('osm')) || null;
+    if (!name || name.length > 160)
+        throw badRequest('Nom de lieu manquant ou trop long (160 caractères au plus).', 'invalid_input');
+    if (zone.length > 120)
+        throw badRequest('Zone trop longue (120 caractères au plus).', 'invalid_input');
+    if (osm !== null && !/^(node|way|relation)\/\d{1,12}$/.test(osm))
+        throw badRequest('Objet OpenStreetMap invalide.', 'invalid_input');
+    return { name, zone, osm };
+}
+export class Fiches {
+    deps;
+    cards = new Map();
+    images = new Map();
+    kept = [];
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async json(url, signal) {
+        const res = await this.deps.fetcher(url, { headers: { 'User-Agent': USER_AGENT, Accept: 'application/json' }, signal: AbortSignal.any([signal, AbortSignal.timeout(WIKI_TIMEOUT_MS)]) });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new AppError('wiki_error', 502, `Wikipédia a répondu ${res.status}.`);
+        return (await res.json());
+    }
+    async summary(lang, title, signal) {
+        const body = await this.json(`https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(title.replace(/ /g, '_'))}`, signal);
+        if (!body || body.type === 'disambiguation')
+            return null;
+        const extract = clean(body.extract);
+        const page = clean(body.content_urls?.desktop?.page);
+        const url = page.startsWith(`https://${lang}.wikipedia.org/`) ? page : `https://${lang}.wikipedia.org/wiki/${encodeURIComponent(title.replace(/ /g, '_'))}`;
+        const thumbnail = clean(body.thumbnail?.source) || null;
+        return extract ? { extract, url, thumbnail } : null;
+    }
+    /** L'article du lieu : l'étiquette wikipedia en français, sinon l'article français ou anglais de son élément Wikidata. */
+    async wiki(tags, signal) {
+        const tagged = /^([a-z]{2,3}):(.{1,250})$/.exec(tags.wikipedia ?? '');
+        if (tagged?.[1] === 'fr' && tagged[2])
+            return this.summary('fr', tagged[2], signal);
+        const qid = tags.wikidata ?? '';
+        if (/^Q\d{1,12}$/.test(qid)) {
+            const body = await this.json(`https://www.wikidata.org/w/api.php?action=wbgetentities&ids=${qid}&props=sitelinks&sitefilter=frwiki%7Cenwiki&format=json`, signal);
+            const links = (body?.entities?.[qid]?.sitelinks ?? {});
+            const fr = clean(links.frwiki?.title);
+            const en = clean(links.enwiki?.title);
+            if (fr)
+                return this.summary('fr', fr, signal);
+            if (en)
+                return this.summary('en', en, signal);
+        }
+        if (tagged?.[1] && tagged[2])
+            return this.summary(tagged[1], tagged[2], signal);
+        return null;
+    }
+    /** Retient une adresse d'image choisie par le serveur et rend son id. Une image data: est décodée tout de suite. */
+    register(url) {
+        const id = crypto.createHash('sha256').update(url).digest('hex').slice(0, 24);
+        if (!this.images.has(id)) {
+            const data = DATA_IMAGE.exec(url);
+            this.images.set(id, data?.[1] && data[2] ? { url: '', type: data[1], bytes: Buffer.from(data[2], 'base64') } : { url });
+            while (this.images.size > MAX_IMAGES)
+                this.images.delete(this.images.keys().next().value);
+        }
+        return id;
+    }
+    async card(request, signal) {
+        const key = JSON.stringify([request.osm, request.name, request.zone]);
+        const cached = this.cards.get(key);
+        if (cached)
+            return cached;
+        // Les étiquettes sont un plus : sans Overpass, ou s'il tarde (essai réel : 40 s pour la Tour Eiffel un jour chargé),
+        // la fiche se cherche par le nom
+        let tags = null;
+        if (request.osm) {
+            try {
+                tags = await this.deps.places().tags(request.osm, AbortSignal.any([signal, AbortSignal.timeout(this.deps.tagsTimeoutMs ?? TAGS_TIMEOUT_MS)]));
+            }
+            catch (err) {
+                if (signal.aborted)
+                    throw err;
+            }
+        }
+        const website = safeWebsite(tags?.website ?? tags?.['contact:website']);
+        let description = null;
+        let descriptionSource = null;
+        let image = null;
+        let note = null;
+        let wiki = null;
+        try {
+            wiki = tags ? await this.wiki(tags, signal) : null;
+        }
+        catch (err) {
+            if (signal.aborted)
+                throw err;
+        }
+        const useWiki = (found) => {
+            description = cut(found.extract, 600);
+            descriptionSource = { label: 'Wikipédia', url: found.url, via: null };
+            if (!image && found.thumbnail && imageAllowed(found.thumbnail))
+                image = { id: this.register(found.thumbnail), source: { label: 'Wikipédia', url: found.url, via: null } };
+        };
+        if (wiki)
+            useWiki(wiki);
+        if (!description || !image) {
+            const query = `${request.name} ${request.zone}`.trim();
+            const backend = this.deps.search();
+            const [web, images] = await Promise.allSettled([description ? Promise.resolve([]) : backend.web(query, signal), image ? Promise.resolve([]) : backend.images(query, signal)]);
+            if (signal.aborted)
+                throw new DOMException('Opération interrompue.', 'AbortError');
+            if (!description && web.status === 'fulfilled') {
+                // L'article Wikipédia du lieu parmi les résultats : son résumé et sa photo valent mieux qu'un extrait
+                const article = wikipediaArticle(web.value, request.name);
+                let fromWiki = null;
+                try {
+                    fromWiki = article ? await this.summary(article.lang, article.title, signal) : null;
+                }
+                catch (err) {
+                    if (signal.aborted)
+                        throw err;
+                }
+                const found = fromWiki ? null : pickDescription(web.value, request.name, website);
+                if (fromWiki)
+                    useWiki(fromWiki);
+                else if (found) {
+                    description = cut(found.text, 600);
+                    descriptionSource = found.source;
+                }
+            }
+            if (!image && images.status === 'fulfilled') {
+                const trusted = [website ? hostOf(website) : null, descriptionSource ? hostOf(descriptionSource.url) : null];
+                const found = pickImage(images.value, request.name, request.zone, trusted);
+                if (found)
+                    image = { id: this.register(found.url), source: found.source };
+            }
+            const failed = [web, images].find((r) => r.status === 'rejected');
+            if (failed)
+                note = describeError(failed.reason).message;
+        }
+        const card = { name: request.name, description, descriptionSource, image, website, note };
+        if (!note) {
+            this.cards.set(key, card);
+            while (this.cards.size > MAX_CARDS)
+                this.cards.delete(this.cards.keys().next().value);
+        }
+        this.deps.onLookup?.(request, card);
+        return card;
+    }
+    /** L'image d'une fiche, téléchargée une fois puis gardée en mémoire (les 100 dernières). */
+    async image(id, signal) {
+        const stored = /^[a-f0-9]{24}$/.test(id) ? this.images.get(id) : undefined;
+        if (!stored)
+            throw new AppError('image_unknown', 404, 'Image inconnue. Rouvre la fiche du lieu.');
+        if (stored.bytes && stored.type)
+            return { bytes: stored.bytes, type: stored.type };
+        if (!imageAllowed(stored.url))
+            throw new AppError('image_unknown', 404, 'Image inconnue. Rouvre la fiche du lieu.');
+        let res;
+        try {
+            res = await this.deps.fetcher(stored.url, { headers: { 'User-Agent': USER_AGENT, Accept: 'image/*' }, redirect: 'error', signal: AbortSignal.any([signal, AbortSignal.timeout(IMAGE_TIMEOUT_MS)]) });
+        }
+        catch (err) {
+            if (signal.aborted)
+                throw err;
+            throw new AppError('image_unreachable', 502, 'L’image n’a pas pu être téléchargée.');
+        }
+        const type = (res.headers.get('content-type') ?? '').split(';')[0]?.trim().toLowerCase() ?? '';
+        const length = Number(res.headers.get('content-length') ?? 0);
+        if (!res.ok)
+            throw new AppError('image_unreachable', 502, `L’image n’a pas pu être téléchargée (${res.status}).`);
+        if (!IMAGE_TYPES.has(type) || length > MAX_IMAGE_BYTES)
+            throw new AppError('image_unreachable', 502, 'Le fichier reçu n’est pas une image utilisable.');
+        const bytes = Buffer.from(await res.arrayBuffer());
+        if (bytes.length > MAX_IMAGE_BYTES || bytes.length === 0)
+            throw new AppError('image_unreachable', 502, 'Le fichier reçu n’est pas une image utilisable.');
+        stored.bytes = bytes;
+        stored.type = type;
+        this.kept.push(id);
+        while (this.kept.length > MAX_IMAGE_BYTES_KEPT) {
+            const old = this.images.get(this.kept.shift());
+            if (old?.url) {
+                delete old.bytes;
+                delete old.type;
+            }
+        }
+        return { bytes, type };
+    }
+}

package/lib/server/search/lieux.js

@@ -0,0 +1,134 @@
+/**
+ * Les points d'une carte à plusieurs lieux : GET /api/map/places (.equipe/recherche/CONTRAT-LIEUX.md).
+ * Le cerveau lance la requête dès qu'il connaît la zone (prefetch), l'interface la lit ensuite : une seule requête Overpass
+ * pour les deux. Le résultat est gardé 7 jours sur le disque ({données}/lieux). Plus vieux, il sert encore si Overpass échoue.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { badRequest } from '../errors.js';
+import { AROUND_RADIUS, categoryByLabel, diagonalKm, MAX_ZONE_KM } from './categories.js';
+const KEEP_MS = 7 * 86_400_000;
+const MAX_MEMORY = 30;
+const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+function parseBox(v) {
+    if (!Array.isArray(v) || v.length !== 4 || !v.every(finite))
+        return null;
+    const [south, north, west, east] = v;
+    if (south < -90 || north > 90 || west < -180 || east > 180 || south > north || west > east)
+        return null;
+    return [south, north, west, east];
+}
+/** La demande de l'interface, vérifiée : une catégorie connue (son filtre vient du serveur) et une zone raisonnable. */
+export function parsePlacesRequest(category, where) {
+    const known = categoryByLabel(category ?? '');
+    if (!known)
+        throw badRequest('Catégorie de lieux inconnue.', 'invalid_input');
+    let raw;
+    try {
+        raw = JSON.parse(where ?? '');
+    }
+    catch {
+        throw badRequest('Zone illisible.', 'invalid_input');
+    }
+    const tooBig = badRequest(`Zone trop grande : ${MAX_ZONE_KM} km de diagonale au plus.`, 'invalid_input');
+    if (raw?.kind === 'area') {
+        const bbox = parseBox(raw.bbox);
+        if (!Number.isInteger(raw.id) || raw.id <= 3_600_000_000 || raw.id >= 3_700_000_000 || !bbox)
+            throw badRequest('Zone invalide.', 'invalid_input');
+        if (diagonalKm(bbox) > MAX_ZONE_KM)
+            throw tooBig;
+        return { category: known, where: { kind: 'area', id: raw.id, bbox } };
+    }
+    if (raw?.kind === 'bbox') {
+        const bbox = parseBox(raw.bbox);
+        if (!bbox)
+            throw badRequest('Zone invalide.', 'invalid_input');
+        if (diagonalKm(bbox) > MAX_ZONE_KM)
+            throw tooBig;
+        return { category: known, where: { kind: 'bbox', bbox } };
+    }
+    if (raw?.kind === 'around') {
+        const { lat, lon, radius } = raw;
+        if (!finite(lat) || !finite(lon) || Math.abs(lat) > 90 || Math.abs(lon) > 180 || !Number.isInteger(radius) || radius < 100 || radius > 5 * AROUND_RADIUS)
+            throw badRequest('Zone invalide.', 'invalid_input');
+        return { category: known, where: { kind: 'around', lat, lon, radius: radius } };
+    }
+    throw badRequest('Zone invalide.', 'invalid_input');
+}
+export class PlacesService {
+    backend;
+    dir;
+    memory = new Map();
+    pending = new Map();
+    constructor(backend, dir) {
+        this.backend = backend;
+        this.dir = dir;
+    }
+    key(category, where) {
+        return crypto.createHash('sha256').update(JSON.stringify([category.filter, where])).digest('hex').slice(0, 32);
+    }
+    read(key) {
+        const inMemory = this.memory.get(key);
+        if (inMemory)
+            return inMemory;
+        if (!this.dir)
+            return null;
+        try {
+            const file = path.join(this.dir, `${key}.json`);
+            const at = fs.statSync(file).mtimeMs;
+            const result = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (!Array.isArray(result.points) || typeof result.total !== 'number')
+                return null;
+            return { at, result };
+        }
+        catch {
+            return null;
+        }
+    }
+    write(key, result) {
+        this.memory.set(key, { at: Date.now(), result });
+        while (this.memory.size > MAX_MEMORY)
+            this.memory.delete(this.memory.keys().next().value);
+        if (!this.dir)
+            return;
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            fs.writeFileSync(path.join(this.dir, `${key}.json`), JSON.stringify(result));
+        }
+        catch {
+            // Un cache qui ne s'écrit pas ne doit pas faire échouer la carte
+        }
+    }
+    /**
+     * Les points, depuis le cache s'il a moins de 7 jours, sinon par Overpass. Deux demandes identiques en même temps n'en
+     * font qu'une. La requête ne dépend pas de qui l'attend : une page fermée ne l'interrompt pas, et le cache se remplit.
+     */
+    get(category, where) {
+        const key = this.key(category, where);
+        const cached = this.read(key);
+        if (cached && Date.now() - cached.at < KEEP_MS)
+            return Promise.resolve(cached.result);
+        const inFlight = this.pending.get(key);
+        if (inFlight)
+            return inFlight;
+        const run = this.backend()
+            .many(category.filter, where, new AbortController().signal)
+            .then((result) => {
+            this.write(key, result);
+            return result;
+        })
+            .catch((err) => {
+            if (cached)
+                return cached.result;
+            throw err;
+        })
+            .finally(() => this.pending.delete(key));
+        this.pending.set(key, run);
+        return run;
+    }
+    /** Lance la requête sans l'attendre : l'interface la retrouvera en vol ou dans le cache. */
+    prefetch(category, where) {
+        this.get(category, where).catch(() => undefined);
+    }
+}