france-data-mcp 0.7.2

package/dist/index.js

@@ -0,0 +1,1674 @@
+import { readFile, mkdir, writeFile, rename, unlink, stat } from 'fs/promises';
+import { createReadStream, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { createClient } from '@supabase/supabase-js';
+
+// src/core/http.ts
+var DEFAULT_USER_AGENT = "france-data-mcp/0.1.0 (+https://github.com/cturkieh/france-data-mcp)";
+var HttpError = class extends Error {
+  constructor(message, status, url, body) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+    this.name = "HttpError";
+  }
+  status;
+  url;
+  body;
+};
+var RateLimitExceededError = class extends HttpError {
+  constructor(url, retryAfter) {
+    super(`Rate limit exceeded after retries on ${url} (retry-after: ${retryAfter}s)`, 429, url);
+    this.name = "RateLimitExceededError";
+  }
+};
+async function fetchJson(url, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 500,
+    userAgent = DEFAULT_USER_AGENT,
+    headers = {},
+    signal
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: "application/json",
+          "User-Agent": userAgent,
+          ...headers
+        },
+        signal
+      });
+      if (response.ok) {
+        return await response.json();
+      }
+      if (response.status === 429) {
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+        if (attempt === maxRetries) {
+          throw new RateLimitExceededError(url, retryAfter);
+        }
+        await sleep(retryAfter * 1e3 + jitter());
+        continue;
+      }
+      if (response.status >= 500 && response.status < 600 && attempt < maxRetries) {
+        await sleep(baseDelayMs * 2 ** attempt + jitter());
+        continue;
+      }
+      const body = await response.text().catch((bodyErr) => {
+        console.warn(
+          `[france-data-mcp] failed to read response body for ${url}: ${bodyErr.message}`
+        );
+        return void 0;
+      });
+      throw new HttpError(
+        `HTTP ${response.status} on ${url}`,
+        response.status,
+        url,
+        body?.slice(0, 500)
+      );
+    } catch (err) {
+      if (err instanceof HttpError) throw err;
+      lastError = err;
+      if (lastError instanceof SyntaxError) {
+        console.error(`[france-data-mcp] invalid JSON response from ${url}: ${lastError.message}`);
+        throw lastError;
+      }
+      if (lastError.name === "AbortError") {
+        console.warn(`[france-data-mcp] fetch aborted (caller signal) on ${url}`);
+        throw lastError;
+      }
+      if (signal?.aborted) {
+        console.warn(
+          `[france-data-mcp] fetch aborted on ${url} (signal already aborted) \u2014 last error: ${lastError.message}`
+        );
+        throw lastError;
+      }
+      const isFinalAttempt = attempt === maxRetries;
+      const log = isFinalAttempt ? console.error : console.warn;
+      log(
+        `[france-data-mcp] network error on ${url} (attempt ${attempt + 1}/${maxRetries + 1}): ${lastError.message}`
+      );
+      if (isFinalAttempt) break;
+      await sleep(baseDelayMs * 2 ** attempt + jitter());
+    }
+  }
+  console.error(`[france-data-mcp] giving up on ${url} after ${maxRetries + 1} attempts`);
+  throw lastError ?? new Error(`Unknown failure fetching ${url}`);
+}
+function parseRetryAfter(header) {
+  if (!header) return 5;
+  const seconds = Number.parseInt(header, 10);
+  if (Number.isFinite(seconds) && seconds > 0) return Math.min(seconds, 60);
+  const dateMs = Date.parse(header);
+  if (Number.isFinite(dateMs)) {
+    const deltaSec = Math.ceil((dateMs - Date.now()) / 1e3);
+    if (deltaSec > 0) return Math.min(deltaSec, 60);
+  }
+  return 5;
+}
+function jitter() {
+  return Math.floor(Math.random() * 250);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/lookup-result.ts
+function lookupFound(entity) {
+  return { ...entity, found: true, lookupStatus: "found" };
+}
+function lookupNotFound(key, message, status = "not_found") {
+  return { found: false, key, lookupStatus: status, message };
+}
+
+// src/core/numbers.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function metersToKm(meters) {
+  if (typeof meters !== "number" || !Number.isFinite(meters)) return null;
+  return Math.round(meters / 1e3 * 100) / 100;
+}
+
+// src/core/object-utils.ts
+function pickDefined(obj) {
+  const out = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (value !== void 0 && value !== "") {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+// src/territoire/communes.ts
+var BASE_URL = "https://geo.api.gouv.fr";
+var DEFAULT_FIELDS = [
+  "nom",
+  "code",
+  "codesPostaux",
+  "centre",
+  "population",
+  "codeDepartement",
+  "codeRegion",
+  "codeEpci"
+].join(",");
+async function searchCommunes(options) {
+  const { nom, codePostal, code, limit = 10, boostPopulation = false, signal } = options;
+  if (!nom && !codePostal && !code) {
+    throw new Error("searchCommunes: au moins un crit\xE8re (nom, codePostal, code) est requis");
+  }
+  const params = new URLSearchParams();
+  if (nom) params.set("nom", nom);
+  if (codePostal) params.set("codePostal", codePostal);
+  if (code) params.set("code", code);
+  params.set("fields", DEFAULT_FIELDS);
+  params.set("limit", String(clamp(limit, 1, 30)));
+  if (boostPopulation) params.set("boost", "population");
+  const url = `${BASE_URL}/communes?${params.toString()}`;
+  const data = await fetchJson(url, { signal });
+  return data.map(toCommune);
+}
+async function getCommuneByCode(code, signal) {
+  const results = await searchCommunes({ code, limit: 1, signal });
+  const first = results[0];
+  if (!first) {
+    return lookupNotFound(
+      code,
+      `Commune introuvable pour le code INSEE "${code}". Causes possibles : code mal form\xE9 (attendu 5 caract\xE8res), commune fusionn\xE9e (r\xE9f\xE9rentiel COG INSEE bouge au 1er janvier), code de canton/EPCI mal interpr\xE9t\xE9 comme commune. Pour disambiguer : utiliser \`autocomplete_commune\` avec un nom partiel.`
+    );
+  }
+  return lookupFound(first);
+}
+function toCommune(api) {
+  const centre = api.centre?.coordinates ? { lon: api.centre.coordinates[0], lat: api.centre.coordinates[1] } : void 0;
+  return {
+    code: api.code,
+    nom: api.nom,
+    codesPostaux: api.codesPostaux ?? [],
+    ...centre ? { centre } : {},
+    ...api.population !== void 0 ? { population: api.population } : {},
+    ...pickDefined({
+      codeDepartement: api.codeDepartement,
+      codeRegion: api.codeRegion,
+      codeEpci: api.codeEpci
+    })
+  };
+}
+
+// src/territoire/geocode.ts
+var BASE_URL2 = "https://data.geopf.fr/geocodage";
+var LOW_SCORE_THRESHOLD = 0.5;
+async function geocode(address, options = {}) {
+  const results = await geocodeMany(address, { ...options, limit: 1 });
+  const top = results[0];
+  if (!top) return null;
+  if (top.score < LOW_SCORE_THRESHOLD) {
+    console.warn(
+      `[france-data-mcp] geocode("${address}"): score ${top.score.toFixed(2)} < ${LOW_SCORE_THRESHOLD} \u2014 r\xE9sultat tr\xE8s incertain (label retourn\xE9: "${top.label}").`
+    );
+  }
+  return top;
+}
+async function geocodeMany(address, options = {}) {
+  const { codePostal, codeCommune, type, limit = 5, signal } = options;
+  const params = new URLSearchParams({ q: address });
+  params.set("limit", String(clamp(limit, 1, 20)));
+  if (codePostal) params.set("postcode", codePostal);
+  if (codeCommune) params.set("citycode", codeCommune);
+  if (type) params.set("type", type);
+  const url = `${BASE_URL2}/search/?${params.toString()}`;
+  const data = await fetchJson(url, { signal });
+  return data.features.map(toGeocodeResult);
+}
+async function reverseGeocode(point, signal) {
+  const params = new URLSearchParams({
+    lon: String(point.lon),
+    lat: String(point.lat)
+  });
+  const url = `${BASE_URL2}/reverse/?${params.toString()}`;
+  const data = await fetchJson(url, { signal });
+  const feature = data.features[0];
+  return feature ? toGeocodeResult(feature) : null;
+}
+function toGeocodeResult(feature) {
+  const [lon, lat] = feature.geometry.coordinates;
+  return {
+    point: { lon, lat },
+    label: feature.properties.label,
+    score: feature.properties.score,
+    type: feature.properties.type,
+    ...pickDefined({
+      codePostal: feature.properties.postcode,
+      codeCommune: feature.properties.citycode,
+      commune: feature.properties.city
+    })
+  };
+}
+
+// src/territoire/index.ts
+var TERRITOIRE_VERSION = "0.1.0";
+
+// src/core/coords.ts
+function parseCoordinates(lon, lat) {
+  const lonNum = parseLooseNumber(lon);
+  const latNum = parseLooseNumber(lat);
+  if (lonNum === void 0 || latNum === void 0) return void 0;
+  return { lon: lonNum, lat: latNum };
+}
+function parseLooseNumber(value) {
+  if (value == null) return void 0;
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  const normalized = value.replace(",", ".");
+  const num = Number.parseFloat(normalized);
+  return Number.isFinite(num) ? num : void 0;
+}
+
+// src/sante/insee-sirene.ts
+var SIRENE_BASE_URL = "https://api.insee.fr/api-sirene/3.11";
+var INSEE_AUTH_HEADER = "X-INSEE-Api-Key-Integration";
+var FETCH_TIMEOUT_MS = 6e4;
+function getInseeApiKey() {
+  const raw = process.env.INSEE_SIRENE_API_KEY;
+  if (!raw) return null;
+  const cleaned = raw.trim().replace(/^["']|["']$/g, "");
+  return cleaned === "" ? null : cleaned;
+}
+async function lookupSirenViaInsee(siren) {
+  const apiKey = getInseeApiKey();
+  if (!apiKey) return null;
+  const url = `${SIRENE_BASE_URL}/siren/${encodeURIComponent(siren)}`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let data;
+  try {
+    data = await fetchJson(url, {
+      headers: { [INSEE_AUTH_HEADER]: apiKey },
+      signal: controller.signal
+    });
+  } catch (err) {
+    const httpStatus = err instanceof HttpError ? err.status : null;
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const logFn = httpStatus === 404 ? console.warn : console.error;
+    logFn(
+      `[france-data-mcp] INSEE SIRENE lookup terminated for siren=${siren} \u2014 ${httpStatus !== null ? `HTTP ${httpStatus}` : `network/parse error: ${errMsg}`}`
+    );
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+  const ul = data.uniteLegale;
+  if (!ul) {
+    console.warn(`[france-data-mcp] INSEE SIRENE response missing uniteLegale for siren=${siren}`);
+    return null;
+  }
+  const periodes = ul.periodesUniteLegale ?? [];
+  let periode = periodes.find((p) => p.dateFin === null || p.dateFin === void 0);
+  if (!periode && periodes.length > 0) {
+    periode = periodes[0];
+    console.warn(
+      `[france-data-mcp] INSEE SIRENE siren=${siren} : aucune p\xE9riode ouverte (dateFin=null), fallback sur periodesUniteLegale[0] (potentiellement obsol\xE8te)`
+    );
+  }
+  return {
+    siren,
+    nomComplet: deriveNomComplet(periode, siren),
+    finances: [],
+    dirigeants: [],
+    actif: periode?.etatAdministratifUniteLegale === "A",
+    etablissements: [],
+    enrichmentStatus: "not_attempted",
+    siren_source: "insee_v3",
+    ...periode?.activitePrincipaleUniteLegale ? { naf: periode.activitePrincipaleUniteLegale } : {},
+    ...periode?.categorieJuridiqueUniteLegale ? { natureJuridique: periode.categorieJuridiqueUniteLegale } : {}
+  };
+}
+function deriveNomComplet(periode, siren) {
+  if (!periode) return siren;
+  const denomination = periode.denominationUniteLegale?.trim();
+  if (denomination) return denomination;
+  const prenom = (periode.prenomUsuelUniteLegale ?? periode.prenom1UniteLegale)?.trim();
+  const nom = periode.nomUniteLegale?.trim();
+  if (prenom && nom) return `${prenom} ${nom}`;
+  if (nom) return nom;
+  return siren;
+}
+
+// src/sante/dinum.ts
+var BASE_URL3 = "https://recherche-entreprises.api.gouv.fr/search";
+async function searchEntreprises(options) {
+  const {
+    q,
+    naf,
+    codePostal,
+    departement,
+    codeCommune,
+    center,
+    radiusKm,
+    onlyActive = true,
+    page = 1,
+    perPage = 10,
+    signal
+  } = options;
+  if (!q && !naf && !codePostal && !departement && !codeCommune && !center) {
+    throw new Error(
+      "searchEntreprises: au moins un crit\xE8re est requis (q, naf, codePostal, departement, codeCommune ou center+radiusKm)"
+    );
+  }
+  if (center && (radiusKm === void 0 || radiusKm <= 0)) {
+    throw new Error("searchEntreprises: radiusKm > 0 requis quand center est fourni");
+  }
+  if (center && !q) {
+    if (naf) {
+      throw new Error(
+        "searchEntreprises: l'API DINUM n'accepte pas `naf` + `center+radiusKm` directement. Options : (1) `q='<terme>'` + center+radiusKm (recherche textuelle g\xE9olocalis\xE9e), (2) `naf` + `codePostal`/`departement`/`codeCommune` (filtrage administratif), (3) faire un reverseGeocode du center pour obtenir codeCommune puis filtrer."
+      );
+    }
+    throw new Error(
+      "searchEntreprises: `center+radiusKm` requiert un param\xE8tre `q` (recherche textuelle). L'API DINUM ne supporte pas la recherche g\xE9ographique pure."
+    );
+  }
+  const params = new URLSearchParams();
+  if (q) params.set("q", q);
+  if (naf) params.set("activite_principale", normalizeNafCode(naf));
+  if (codePostal) params.set("code_postal", codePostal);
+  if (departement) params.set("departement", departement);
+  if (codeCommune) params.set("code_commune", codeCommune);
+  if (center && radiusKm !== void 0) {
+    params.set("lat", String(center.lat));
+    params.set("long", String(center.lon));
+    params.set("radius", String(Math.min(radiusKm, 50)));
+  }
+  if (onlyActive) params.set("etat_administratif", "A");
+  params.set("page", String(Math.max(1, page)));
+  params.set("per_page", String(clamp(perPage, 1, 25)));
+  const url = `${BASE_URL3}?${params.toString()}`;
+  const data = await fetchJson(url, { signal });
+  return {
+    total: data.total_results,
+    page: data.page,
+    perPage: data.per_page,
+    totalPages: data.total_pages,
+    entreprises: data.results.map(toEntreprise)
+  };
+}
+async function getEntrepriseBySiren(siren, signal) {
+  if (!/^\d{9}$/.test(siren)) {
+    throw new Error(`getEntrepriseBySiren: SIREN invalide "${siren}" (attendu 9 chiffres)`);
+  }
+  const result = await searchEntreprises({ q: siren, perPage: 5, onlyActive: false, signal });
+  const match = result.entreprises.find((e) => e.siren === siren);
+  if (!match) {
+    if (result.entreprises.length > 0) {
+      console.warn(
+        `[france-data-mcp] getEntrepriseBySiren(${siren}): l'API a renvoy\xE9 ${result.entreprises.length} r\xE9sultat(s) sans match exact du SIREN.`
+      );
+      return lookupNotFound(
+        siren,
+        `L'API DINUM a renvoy\xE9 ${result.entreprises.length} r\xE9sultat(s) full-text mais aucun ne correspond exactement au SIREN ${siren}. Possible r\xE9gression c\xF4t\xE9 API DINUM ou faux positif full-text.`,
+        "ambiguous"
+      );
+    }
+    const inseeMatch = await lookupSirenViaInsee(siren);
+    if (inseeMatch) return lookupFound(inseeMatch);
+    const inseeSuffix = getInseeApiKey() ? "Fallback SIRENE INSEE V3 a aussi retourn\xE9 null (SIREN absent de SIRENE, cl\xE9 r\xE9voqu\xE9e, ou panne API \u2014 voir logs)." : "Fallback SIRENE INSEE V3 non configur\xE9 (env var INSEE_SIRENE_API_KEY absente).";
+    return lookupNotFound(
+      siren,
+      `SIREN ${siren} non trouv\xE9 via DINUM (statut diffusion partielle probable). ${inseeSuffix}`
+    );
+  }
+  const siege = match.etablissements.find((e) => e.siret === match.siretSiege) ?? match.etablissements[0];
+  const siegePostalCode = siege?.codePostal;
+  const departement = deptFromPostal(siegePostalCode);
+  const naf = match.naf;
+  const totalSirene = match.nombreEtablissements ?? 0;
+  if (totalSirene <= 1) {
+    match.enrichmentStatus = "not_attempted";
+    return lookupFound(match);
+  }
+  if (!naf || !departement) {
+    match.enrichmentStatus = "not_attempted";
+    match.enrichmentWarning = warnSkipped({ naf, siegePostalCode, departement });
+    return lookupFound(match);
+  }
+  try {
+    const more = await searchEntreprises({
+      naf,
+      departement,
+      perPage: 25,
+      onlyActive: false,
+      signal
+    });
+    const enriched = more.entreprises.find((e) => e.siren === siren);
+    if (enriched) {
+      const seen = new Set(match.etablissements.map((e) => e.siret));
+      for (const et of enriched.etablissements) {
+        if (et.siret && !seen.has(et.siret)) {
+          match.etablissements.push(et);
+          seen.add(et.siret);
+        }
+      }
+    }
+    if (match.etablissements.length >= totalSirene) {
+      match.enrichmentStatus = "success";
+    } else {
+      match.enrichmentStatus = "partial";
+      match.enrichmentWarning = warnPartial({
+        found: match.etablissements.length,
+        totalSirene,
+        naf,
+        departement
+      });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errType = err instanceof Error ? err.constructor.name : typeof err;
+    console.error(
+      `[france-data-mcp] getEntrepriseBySiren(${siren}): \xE9chec enrichissement (errType=${errType}, naf=${naf}, departement=${departement}): ${msg}`
+    );
+    match.enrichmentStatus = "failed";
+    match.enrichmentWarning = warnFailed({ errType, msg, totalSirene });
+  }
+  return lookupFound(match);
+}
+function warnSkipped(opts) {
+  return `Enrichissement ignor\xE9 (naf=${opts.naf ?? "absent"}, codePostal=${opts.siegePostalCode ?? "absent"}, departement=${opts.departement ?? "non d\xE9ductible"}).`;
+}
+function warnPartial(opts) {
+  return `Enrichissement partiel : ${opts.found}/${opts.totalSirene} \xE9tablissements. Strat\xE9gie API DINUM (naf=${opts.naf} + departement=${opts.departement}) ne couvre pas les sites multi-d\xE9partement ni les \xE9tablissements \xE0 NAF diff\xE9rent du si\xE8ge. Pour exhaustivit\xE9 : utiliser \`entreprises_in_radius\` par zone g\xE9ographique, ou interroger SIRENE directement.`;
+}
+function warnFailed(opts) {
+  return `Enrichissement \xE9chou\xE9 (${opts.errType}: ${opts.msg}). nombreEtablissements=${opts.totalSirene} mais seul le si\xE8ge est list\xE9. R\xE9essayer plus tard, ou utiliser \`entreprises_in_radius\` pour cibler g\xE9ographiquement.`;
+}
+function deptFromPostal(codePostal) {
+  if (!codePostal || codePostal.length < 2) return void 0;
+  if (codePostal.startsWith("97") || codePostal.startsWith("98")) {
+    return codePostal.length >= 3 ? codePostal.slice(0, 3) : void 0;
+  }
+  if (codePostal.startsWith("20") && /^\d{5}$/.test(codePostal)) {
+    const n = Number.parseInt(codePostal, 10);
+    if (n >= 2e4 && n <= 20190) return "2A";
+    if (n >= 20200 && n <= 20620) return "2B";
+    return void 0;
+  }
+  return codePostal.slice(0, 2);
+}
+function normalizeNafCode(naf) {
+  if (/^\d{2}\.\d{2}[A-Z]$/.test(naf)) return naf;
+  if (/^\d{4}[A-Z]$/.test(naf)) return `${naf.slice(0, 2)}.${naf.slice(2)}`;
+  return naf;
+}
+function toEntreprise(api) {
+  const finances = [];
+  if (api.finances) {
+    for (const [year, fin] of Object.entries(api.finances)) {
+      const annee = Number.parseInt(year, 10);
+      if (Number.isFinite(annee)) {
+        const caFiable = !(fin.ca === 0 && fin.resultat_net !== void 0 && fin.resultat_net > 0);
+        const f = { annee, caFiable };
+        if (fin.ca !== void 0) f.ca = fin.ca;
+        if (fin.resultat_net !== void 0) f.resultatNet = fin.resultat_net;
+        finances.push(f);
+      }
+    }
+    finances.sort((a, b) => b.annee - a.annee);
+  }
+  const etablissements = [];
+  if (api.siege) etablissements.push(toEtablissement(api.siege));
+  if (api.matching_etablissements) {
+    for (const m of api.matching_etablissements) {
+      if (!api.siege || m.siret !== api.siege.siret) {
+        etablissements.push(toEtablissement(m));
+      }
+    }
+  }
+  const entreprise = {
+    siren: api.siren,
+    nomComplet: api.nom_complet ?? api.nom_raison_sociale ?? api.siren,
+    finances,
+    dirigeants: (api.dirigeants ?? []).map(toDirigeant),
+    etablissements,
+    actif: (api.etat_administratif ?? "A") === "A",
+    // Toujours présent côté retour DINUM pour cohérence du contrat caller :
+    // distingue explicitement "DINUM a répondu" du fallback "insee_v3".
+    siren_source: "dinum",
+    ...pickDefined({
+      siretSiege: api.siege?.siret,
+      naf: api.activite_principale,
+      nafLibelle: api.libelle_activite_principale,
+      trancheEffectif: api.tranche_effectif_salarie,
+      natureJuridique: api.nature_juridique
+    })
+  };
+  if (api.nombre_etablissements !== void 0) {
+    entreprise.nombreEtablissements = api.nombre_etablissements;
+  }
+  if (api.nombre_etablissements_ouverts !== void 0) {
+    entreprise.nombreEtablissementsOuverts = api.nombre_etablissements_ouverts;
+  }
+  return entreprise;
+}
+function toDirigeant(api) {
+  return pickDefined({
+    nom: api.nom,
+    prenoms: api.prenoms,
+    fonction: api.fonction,
+    qualite: api.qualite
+  });
+}
+function toEtablissement(api) {
+  const point = parseCoordinates(api.longitude, api.latitude);
+  return {
+    siret: api.siret ?? "",
+    adresse: api.adresse ?? "",
+    actif: (api.etat_administratif ?? "A") === "A",
+    ...pickDefined({
+      codePostal: api.code_postal,
+      commune: api.libelle_commune,
+      naf: api.activite_principale,
+      trancheEffectif: api.tranche_effectif_salarie,
+      dateCreation: api.date_creation
+    }),
+    ...point ? { point } : {}
+  };
+}
+var DEFAULT_CACHE_DIR = join(homedir(), ".cache", "france-data-mcp");
+async function downloadWithCache(url, cacheFileName, options = {}) {
+  const {
+    cacheDir = DEFAULT_CACHE_DIR,
+    ttlMs = 7 * 24 * 60 * 60 * 1e3,
+    force = false,
+    userAgent = DEFAULT_USER_AGENT,
+    signal
+  } = options;
+  const cachePath = join(cacheDir, cacheFileName);
+  if (!force && await isCacheFresh(cachePath, ttlMs)) {
+    return cachePath;
+  }
+  await mkdir(dirname(cachePath), { recursive: true });
+  const response = await fetch(url, {
+    headers: { "User-Agent": userAgent },
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download ${url}: HTTP ${response.status} ${response.statusText}`);
+  }
+  const tmpPath = `${cachePath}.tmp.${process.pid}`;
+  try {
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await writeFile(tmpPath, buffer);
+    await rename(tmpPath, cachePath);
+    return cachePath;
+  } catch (err) {
+    console.error(
+      `[france-data-mcp] cache write failed for ${url} \u2192 ${cachePath}: ${err.message}`
+    );
+    await unlink(tmpPath).catch((unlinkErr) => {
+      const code = unlinkErr.code;
+      if (code !== "ENOENT") {
+        console.warn(
+          `[france-data-mcp] failed to clean up temp cache file ${tmpPath} (${code ?? "unknown"}): ${unlinkErr.message}`
+        );
+      }
+    });
+    throw err;
+  }
+}
+async function isCacheFresh(filePath, ttlMs) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const stats = await stat(filePath);
+    const ageMs = Date.now() - stats.mtimeMs;
+    return ageMs < ttlMs;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return false;
+    console.error(
+      `[france-data-mcp] cache stat failed unexpectedly for ${filePath} (${code ?? "unknown"}): ${err.message}`
+    );
+    throw err;
+  }
+}
+
+// src/core/csv.ts
+var BOM = "\uFEFF";
+function parseCsvLine(line, options = {}) {
+  const delimiter = options.delimiter ?? ";";
+  const quote = options.quote ?? '"';
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < line.length) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === quote) {
+        if (line[i + 1] === quote) {
+          current += quote;
+          i += 2;
+          continue;
+        }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === quote) {
+      inQuotes = true;
+      i++;
+      continue;
+    }
+    if (char === delimiter) {
+      fields.push(current);
+      current = "";
+      i++;
+      continue;
+    }
+    current += char;
+    i++;
+  }
+  fields.push(current);
+  return fields;
+}
+function parseCsv(content, options = {}) {
+  const cleaned = content.startsWith(BOM) ? content.slice(BOM.length) : content;
+  const lines = cleaned.split(/\r?\n/);
+  const result = [];
+  if (lines.length === 0) return result;
+  const headers = parseCsvLine(lines[0] ?? "", options);
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const values = parseCsvLine(line, options);
+    const record = {};
+    for (let j = 0; j < headers.length; j++) {
+      const header = headers[j];
+      if (header) record[header] = values[j] ?? "";
+    }
+    result.push(record);
+  }
+  return result;
+}
+async function* streamCsvLines(source, options = {}) {
+  let buffer = "";
+  let headers = null;
+  let firstChunk = true;
+  for await (const chunk of source) {
+    const data = firstChunk && chunk.startsWith(BOM) ? chunk.slice(BOM.length) : chunk;
+    firstChunk = false;
+    buffer += data;
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line) continue;
+      if (!headers) {
+        headers = parseCsvLine(line, options);
+        continue;
+      }
+      yield rowToObject(headers, parseCsvLine(line, options));
+    }
+  }
+  if (buffer.trim().length > 0 && headers) {
+    yield rowToObject(headers, parseCsvLine(buffer, options));
+  }
+}
+function rowToObject(headers, values) {
+  const obj = {};
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i];
+    if (header) obj[header] = values[i] ?? "";
+  }
+  return obj;
+}
+
+// src/sante/finess-categories.ts
+var FINESS_CATEGORIES = {
+  // ─── SANITAIRE — court séjour (MCO + adjacents) ───────────────────────
+  "101": "Centre Hospitalier R\xE9gional (C.H.R.)",
+  "106": "Centre hospitalier",
+  "108": "Centre Hospitalier Universitaire (C.H.U.)",
+  "114": "H\xF4pital des arm\xE9es",
+  "115": "Etablissement de Soins du Service de Sant\xE9 des Arm\xE9es",
+  "128": "Etablissement de Soins Chirurgicaux",
+  "129": "Etablissement de Soins M\xE9dicaux",
+  "131": "Centre de Lutte Contre le Cancer (C.L.C.C.)",
+  "355": "Centre Hospitalier (C.H.)",
+  "365": "Etablissement de Soins Pluridisciplinaire",
+  // ─── SANITAIRE — SSR / SLD / HAD / dialyse ────────────────────────────
+  "109": "Etablissement de sant\xE9 priv\xE9 autoris\xE9 en SSR",
+  "362": "Etablissement de Soins Longue Dur\xE9e (USLD)",
+  "127": "Hospitalisation \xE0 Domicile (HAD)",
+  "141": "Centre de dialyse",
+  "146": "Structure d'Alternative \xE0 la dialyse en centre",
+  // ─── SANITAIRE — psychiatrie ──────────────────────────────────────────
+  "292": "Centre Hospitalier Sp\xE9cialis\xE9 lutte Maladies Mentales",
+  "156": "Centre M\xE9dico-Psychologique (C.M.P.)",
+  "161": "Maison de Sant\xE9 pour Maladies Mentales",
+  "425": "Centre d'Accueil Th\xE9rapeutique \xE0 temps partiel (C.A.T.T.P.)",
+  "430": "Centre Postcure Malades Mentaux",
+  // ─── AMBULATOIRE / soins de ville ─────────────────────────────────────
+  "124": "Centre de Sant\xE9",
+  "603": "Maison de sant\xE9 (L.6223-3)",
+  "604": "Communaut\xE9s professionnelles territoriales de sant\xE9 (CPTS)",
+  // ─── PHARMACIE / BIO / IMAGERIE ───────────────────────────────────────
+  "611": "Laboratoire de Biologie M\xE9dicale",
+  "619": "Cabinet d'imagerie m\xE9dicale",
+  "620": "Pharmacie d'Officine",
+  "627": "Propharmacie",
+  // ─── PERSONNES ÂGÉES — hébergement ────────────────────────────────────
+  "500": "Etablissement d'h\xE9bergement pour personnes \xE2g\xE9es d\xE9pendantes (EHPAD)",
+  "501": "EHPA percevant des cr\xE9dits d'assurance maladie",
+  "502": "EHPA ne percevant pas des cr\xE9dits d'assurance maladie",
+  "202": "R\xE9sidences autonomie",
+  // ─── PERSONNES ÂGÉES — accompagnement ─────────────────────────────────
+  "207": "Centre de Jour pour Personnes Ag\xE9es",
+  "463": "Centres Locaux Information Coordination P.A. (C.L.I.C.)",
+  // ─── DOMICILE (médico-social + soins) ─────────────────────────────────
+  "354": "Service de Soins Infirmiers \xE0 Domicile (S.S.I.A.D.)",
+  "460": "Service d'Aide et d'Accompagnement \xE0 Domicile (S.A.A.D.)",
+  "209": "Service Polyvalent Aide et Soins \xE0 Domicile (S.P.A.S.A.D.)",
+  // ─── HANDICAP ENFANTS ─────────────────────────────────────────────────
+  "182": "Service d'\xC9ducation Sp\xE9ciale et de Soins \xE0 Domicile (SESSAD)",
+  "183": "Institut M\xE9dico-\xC9ducatif (I.M.E.)",
+  "186": "Institut Th\xE9rapeutique \xC9ducatif et P\xE9dagogique (I.T.E.P.)",
+  "188": "Etablissement pour Enfants ou Adolescents Polyhandicap\xE9s",
+  "189": "Centre M\xE9dico-Psycho-P\xE9dagogique (C.M.P.P.)",
+  "190": "Centre Action M\xE9dico-Sociale Pr\xE9coce (C.A.M.S.P.)",
+  "192": "Institut d'\xE9ducation motrice",
+  "194": "Institut pour D\xE9ficients Visuels",
+  "195": "Institut pour D\xE9ficients Auditifs",
+  "196": "Institut d'Education Sensorielle Sourd/Aveugle",
+  // ─── HANDICAP ADULTES ─────────────────────────────────────────────────
+  "246": "Etablissement et Service d'Aide par le Travail (E.S.A.T.)",
+  "247": "Entreprise adapt\xE9e",
+  "252": "Foyer H\xE9bergement Adultes Handicap\xE9s",
+  "255": "Maison d'Accueil Sp\xE9cialis\xE9e (M.A.S.)",
+  "382": "Foyer de Vie pour Adultes Handicap\xE9s",
+  "437": "Foyer d'Accueil M\xE9dicalis\xE9 pour Adultes Handicap\xE9s (F.A.M.)",
+  "445": "Service d'accompagnement m\xE9dico-social adultes handicap\xE9s (SAMSAH)",
+  "446": "Service d'Accompagnement \xE0 la Vie Sociale (S.A.V.S.)",
+  "448": "Etab. Acc. M\xE9dicalis\xE9 en tout ou partie personnes handicap\xE9es",
+  "449": "Etab. Accueil Non M\xE9dicalis\xE9 pour personnes handicap\xE9es",
+  "600": "Foyer d'h\xE9bergement pour adultes handicap\xE9s",
+  // ─── ADDICTOLOGIE / accompagnement ────────────────────────────────────
+  "165": "Appartement de Coordination Th\xE9rapeutique (A.C.T.)",
+  "178": "Centre Accueil/Accomp. R\xE9duc. Risq. Usag. Drogues (C.A.A.R.U.D.)",
+  "180": "Lits Halte Soins Sant\xE9 (L.H.S.S.)",
+  "197": "Centre soins accompagnement pr\xE9vention addictologie (C.S.A.P.A.)",
+  "412": "Appartement Th\xE9rapeutique",
+  // ─── ENFANCE / PROTECTION ─────────────────────────────────────────────
+  "175": "Foyer de l'Enfance",
+  "177": "Maison d'Enfants \xE0 Caract\xE8re Social (MECS)",
+  "295": "Services AEMO et AED",
+  "236": "Centre Placement Familial Socio-Educatif (C.P.F.S.E.)",
+  "238": "Centre d'Accueil Familial Sp\xE9cialis\xE9",
+  "241": "Foyer d'Action Educative (F.A.E.)",
+  "440": "Service Investigation Orientation Educative (S.I.O.E.)",
+  "441": "Centre d'Action Educative (C.A.E.)",
+  "378": "Etablissement Exp\xE9rimental Enfance Prot\xE9g\xE9e",
+  // ─── PMI / PETITE ENFANCE / SANTÉ SCOLAIRE ────────────────────────────
+  "223": "Protection Maternelle et Infantile (P.M.I.)",
+  "228": "Centre Planification ou Education Familiale",
+  "230": "Etablissement Consultation Protection Infantile",
+  "268": "Centre M\xE9dico-Scolaire",
+  // ─── HÉBERGEMENT SOCIAL ───────────────────────────────────────────────
+  "214": "Centre H\xE9bergement & R\xE9insertion Sociale (C.H.R.S.)",
+  "219": "Autre Centre d'Accueil",
+  "256": "Foyer Travailleurs Migrants non transform\xE9 en R\xE9sidence Sociale",
+  "257": "Foyer de Jeunes Travailleurs (r\xE9sidence sociale ou non)",
+  "258": "Maisons Relais - Pensions de Famille",
+  "259": "Autre R\xE9sidence Sociale (hors Maison Relais)",
+  "443": "Centre Accueil Demandeurs Asile (C.A.D.A.)",
+  "442": "Centre Provisoire H\xE9bergement (C.P.H.)",
+  "462": "Lieux de vie",
+  "166": "Etablissement d'Accueil M\xE8re-Enfant",
+  // ─── PRÉVENTION / SANTÉ PUBLIQUE ──────────────────────────────────────
+  "132": "Etablissement de Transfusion Sanguine",
+  "142": "Dispensaire Antituberculeux",
+  "143": "Centre de Vaccination BCG",
+  "266": "Dispensaire Antiv\xE9n\xE9rien",
+  "347": "Centre d'Examens de Sant\xE9",
+  "636": "Centre de soins et de pr\xE9vention",
+  // ─── GROUPEMENTS ──────────────────────────────────────────────────────
+  "696": "Groupement de coop\xE9ration sanitaire de moyens",
+  "697": "Groupement de coop\xE9ration sanitaire \u2014 Etablissement de sant\xE9",
+  // ─── HORS TAXONOMIE (voir DELIBERATELY_AUTRE pour la justification) ───
+  "126": "Etablissement Thermal",
+  "632": "Structure Dispensatrice \xE0 domicile d'Oxyg\xE8ne \xE0 usage m\xE9dical",
+  "698": "Autre Etablissement Loi Hospitali\xE8re"
+};
+function libelleCategorieFiness(code) {
+  return FINESS_CATEGORIES[code];
+}
+var FINESS_FAMILY_CODES = {
+  // Sanitaire — court séjour
+  mco: ["101", "106", "108", "114", "115", "128", "129", "131", "355", "365"],
+  ssr: ["109"],
+  sld: ["362"],
+  had: ["127"],
+  psychiatrie: ["292", "156", "161", "425", "430"],
+  dialyse: ["141", "146"],
+  ambulatoire: ["124"],
+  // Bio / pharma / imagerie
+  labo: ["611"],
+  imagerie: ["619"],
+  pharmacie: ["620", "627"],
+  // Pluri-pro
+  msp_cpts: ["603", "604"],
+  // Personnes âgées
+  ehpad: ["500", "501", "502"],
+  residence_autonomie: ["202"],
+  senior_accompagnement: ["207", "463"],
+  // Domicile
+  ssiad: ["354"],
+  aide_domicile: ["460", "209"],
+  // Handicap
+  handicap_enfants: ["182", "183", "186", "188", "189", "190", "192", "194", "195", "196"],
+  handicap_adultes: ["246", "247", "252", "255", "382", "437", "445", "446", "448", "449", "600"],
+  // Addictologie + précarité sanitaire
+  addictologie: ["165", "178", "180", "197", "412"],
+  // Enfance / protection
+  enfance_protection: ["175", "177", "236", "238", "241", "295", "378", "440", "441"],
+  // PMI / petite enfance
+  pmi: ["223", "228", "230", "268"],
+  // Hébergement social
+  hebergement_social: ["166", "214", "219", "256", "257", "258", "259", "442", "443", "462"],
+  // Prévention / santé publique
+  prevention_sante: ["132", "142", "143", "266", "347", "636"],
+  // Groupements
+  groupement: ["696", "697"]
+};
+var FAMILY_BY_CODE = new Map(
+  Object.keys(FINESS_FAMILY_CODES).flatMap(
+    (fam) => FINESS_FAMILY_CODES[fam].map((code) => [code, fam])
+  )
+);
+function finessFamille(code) {
+  const trimmed = code?.trim();
+  if (!trimmed) return "autre";
+  return FAMILY_BY_CODE.get(trimmed) ?? "autre";
+}
+var FINESS_HOPITAUX = [
+  ...FINESS_FAMILY_CODES.mco,
+  ...FINESS_FAMILY_CODES.ssr,
+  ...FINESS_FAMILY_CODES.sld,
+  ...FINESS_FAMILY_CODES.had,
+  ...FINESS_FAMILY_CODES.psychiatrie
+];
+var FINESS_LABOS = FINESS_FAMILY_CODES.labo;
+var FINESS_PHARMACIES = FINESS_FAMILY_CODES.pharmacie;
+var FINESS_EHPAD = FINESS_FAMILY_CODES.ehpad;
+var FINESS_MSP_CPTS = FINESS_FAMILY_CODES.msp_cpts;
+
+// src/sante/finess.ts
+var FINESS_CSV_URL = "https://www.data.gouv.fr/api/1/datasets/r/3dc9b1d5-0157-440d-a7b5-c894fcfdfd45";
+var FINESS_CACHE_FILE = "finess-etablissements.csv";
+async function loadFiness(options = {}) {
+  const csvPath = options.csvPath ?? await downloadWithCache(FINESS_CSV_URL, FINESS_CACHE_FILE, options);
+  const content = await readFile(csvPath, "utf-8");
+  const rows = parseCsv(content, { delimiter: ";" });
+  const ets = [];
+  for (const row of rows) {
+    const e = toEtablissementFiness(row);
+    if (e !== null) ets.push(e);
+  }
+  const total = rows.length;
+  if (total > 100) {
+    const dropRate = (total - ets.length) / total;
+    if (dropRate > 0.05) {
+      console.error(
+        `[france-data-mcp] FINESS: ${total - ets.length}/${total} lignes invalides (${(dropRate * 100).toFixed(1)}%). Sch\xE9ma CSV probablement chang\xE9. Colonnes attendues: nofinesset, rs, categetab, cpostal, commune. Migration ANS pr\xE9vue \xE9t\xE9 2026 \u2014 v\xE9rifier github.com/ansforge/finess et https://www.data.gouv.fr/datasets/finess-extraction-du-fichier-des-etablissements-sanitaires-et-sociaux/`
+      );
+    }
+  }
+  return ets;
+}
+function searchEtablissementsFiness(index, options) {
+  const { categories, codePostal, departement, codeCommune, center, radiusKm, limit } = options;
+  if (center && (radiusKm === void 0 || radiusKm <= 0)) {
+    throw new Error("searchEtablissementsFiness: radiusKm > 0 requis quand center est fourni");
+  }
+  const radiusMeters = center && radiusKm !== void 0 ? radiusKm * 1e3 : null;
+  const categoriesSet = categories ? new Set(categories) : null;
+  const matches = [];
+  for (const e of index) {
+    if (categoriesSet && (!e.categorieCode || !categoriesSet.has(e.categorieCode))) continue;
+    if (codePostal && e.codePostal !== codePostal) continue;
+    if (departement && e.departement !== departement) continue;
+    if (codeCommune && e.codeCommune !== codeCommune) continue;
+    if (center && radiusMeters !== null) {
+      if (!e.point) continue;
+      if (haversineDistance(center, e.point) > radiusMeters) continue;
+    }
+    matches.push(e);
+    if (limit !== void 0 && matches.length >= limit) break;
+  }
+  return matches;
+}
+function haversineDistance(a, b) {
+  const R = 6371e3;
+  const lat1 = toRad(a.lat);
+  const lat2 = toRad(b.lat);
+  const deltaLat = toRad(b.lat - a.lat);
+  const deltaLon = toRad(b.lon - a.lon);
+  const h = Math.sin(deltaLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLon / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(h));
+}
+function toRad(deg) {
+  return deg * Math.PI / 180;
+}
+function toEtablissementFiness(row) {
+  const finessEt = row.nofinesset ?? row["FINESS ET"] ?? row.finesset;
+  if (!finessEt) return null;
+  const categorieCode = row.categetab ?? row.categagretab ?? row.libcategetab;
+  const categorieLibelle = categorieCode ? libelleCategorieFiness(categorieCode) ?? row.libcategetab : void 0;
+  const adresseParts = [row.numvoie, row.typvoie, row.voie, row.compvoie].filter(Boolean);
+  const adresse = adresseParts.length > 0 ? adresseParts.join(" ").trim() : row.adresse;
+  const point = parseCoordinates(row.coordxet ?? row.longitude, row.coordyet ?? row.latitude);
+  return {
+    finessEt,
+    raisonSociale: row.rs ?? row.raisonsociale ?? row["Raison sociale"] ?? row.rslongue ?? "",
+    ...pickDefined({
+      finessEj: row.nofinessej ?? row["FINESS EJ"] ?? row.finessej,
+      categorieCode,
+      categorieLibelle,
+      adresse,
+      codePostal: row.cpostal ?? row.codepostal,
+      commune: row.commune ?? row.libcommune,
+      codeCommune: row.codecommune ?? row.codinsee,
+      departement: row.departement ?? row.codedepartement,
+      telephone: row.telephone ?? row.tel,
+      siren: row.siren
+    }),
+    ...point ? { point } : {}
+  };
+}
+var ANNUAIRE_AMELI_CSV_URL = "https://www.data.gouv.fr/api/1/datasets/r/3a700a1c-3079-4f7f-9bd7-83611e3f5e35";
+var ANNUAIRE_AMELI_CACHE_FILE = "annuaire-sante-ameli-ps.csv";
+async function ensureAnnuaireAmeli(options = {}) {
+  if (options.csvPath) return options.csvPath;
+  return downloadWithCache(ANNUAIRE_AMELI_CSV_URL, ANNUAIRE_AMELI_CACHE_FILE, options);
+}
+async function* streamProfessionnels(options = {}) {
+  const csvPath = await ensureAnnuaireAmeli(options);
+  const fileStream = createReadStream(csvPath, { encoding: "utf-8" });
+  const {
+    codePostal,
+    codePostalPrefix,
+    commune,
+    specialite,
+    specialiteCode,
+    typePs,
+    secteurConventionnel,
+    limit
+  } = options;
+  const specialiteLower = specialite?.toLowerCase();
+  const communeLower = commune?.toLowerCase();
+  const typePsLower = typePs?.toLowerCase();
+  let yielded = 0;
+  let parsed = 0;
+  let skipped = 0;
+  try {
+    const stringStream = nodeReadableToAsyncIterable(fileStream);
+    for await (const row of streamCsvLines(stringStream, { delimiter: ";" })) {
+      parsed++;
+      const ps = toProfessionnelSante(row);
+      if (!ps) {
+        skipped++;
+        continue;
+      }
+      if (codePostal && ps.codePostal !== codePostal) continue;
+      if (codePostalPrefix && (!ps.codePostal || !ps.codePostal.startsWith(codePostalPrefix)))
+        continue;
+      if (communeLower && (!ps.commune || !ps.commune.toLowerCase().includes(communeLower)))
+        continue;
+      if (specialiteLower && (!ps.specialiteLibelle || !ps.specialiteLibelle.toLowerCase().includes(specialiteLower)))
+        continue;
+      if (specialiteCode && ps.specialiteCode !== specialiteCode) continue;
+      if (typePsLower && (!ps.typePsLibelle || !ps.typePsLibelle.toLowerCase().includes(typePsLower)))
+        continue;
+      if (secteurConventionnel && ps.secteurConventionnel !== secteurConventionnel) continue;
+      yield ps;
+      yielded++;
+      if (limit !== void 0 && yielded >= limit) return;
+    }
+  } finally {
+    fileStream.destroy();
+    if (parsed > 100 && skipped > parsed * 0.1) {
+      console.warn(
+        `[france-data-mcp] annuaire-ameli: ${skipped}/${parsed} lignes invalides (${(skipped / parsed * 100).toFixed(1)}%). Sch\xE9ma CSV peut-\xEAtre chang\xE9. Colonnes attendues: ps_activite_nom, ps_activite_prenom, specialite_libelle, coordonnees_code_postal, coordonnees_ville. V\xE9rifier https://www.data.gouv.fr/datasets/annuaire-sante-ameli/`
+      );
+    }
+  }
+}
+async function loadProfessionnels(options = {}) {
+  const result = [];
+  for await (const ps of streamProfessionnels(options)) {
+    result.push(ps);
+  }
+  return result;
+}
+async function* nodeReadableToAsyncIterable(readable) {
+  try {
+    for await (const chunk of readable) {
+      yield typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    }
+  } finally {
+    if ("destroy" in readable && typeof readable.destroy === "function") {
+      readable.destroy();
+    }
+  }
+}
+function toProfessionnelSante(row) {
+  const nom = row.ps_activite_nom ?? "";
+  const prenom = row.ps_activite_prenom ?? "";
+  if (!nom && !prenom) return null;
+  return {
+    nom,
+    prenom,
+    ...pickDefined({
+      civilite: row.ps_activite_civilite,
+      raisonSociale: row.ps_activite_raison_sociale,
+      specialiteCode: row.specialite_code,
+      specialiteLibelle: row.specialite_libelle,
+      typePsCode: row.type_ps_code,
+      typePsLibelle: row.type_ps_libelle,
+      adresse: row.coordonnees_voie,
+      complementAdresse: row.coordonnees_complement || row.coordonnees_lieu_dit,
+      codePostal: row.coordonnees_code_postal,
+      commune: row.coordonnees_ville,
+      telephone: row.coordonnees_num_tel,
+      secteurConventionnel: row.secteur_conventionnel_code,
+      secteurConventionnelLibelle: row.secteur_conventionnel_libelle,
+      natureExercice: row.nature_exercice_libelle || row.nature_exercice_code
+    })
+  };
+}
+
+// src/sante/naf-codes.ts
+var NAF_SANTE = {
+  // Hôpitaux et cliniques
+  "8610Z": "Activit\xE9s hospitali\xE8res",
+  // Pratique médicale et dentaire
+  "8621Z": "Activit\xE9s de m\xE9decine g\xE9n\xE9rale",
+  "8622A": "Activit\xE9s de radiodiagnostic et de radioth\xE9rapie",
+  "8622B": "Activit\xE9s chirurgicales",
+  "8622C": "Autres activit\xE9s des m\xE9decins sp\xE9cialistes",
+  "8623Z": "Pratique dentaire",
+  // Autres activités de santé
+  "8690A": "Ambulances",
+  "8690B": "Laboratoires d'analyses m\xE9dicales",
+  "8690C": "Centres de collecte et banques d'organes",
+  "8690D": "Activit\xE9s des infirmiers et des sages-femmes",
+  "8690E": "Activit\xE9s des professionnels de la r\xE9\xE9ducation, de l'appareillage et des p\xE9dicures-podologues",
+  "8690F": "Activit\xE9s de sant\xE9 humaine non class\xE9es ailleurs",
+  // Hébergement médico-social
+  "8710A": "H\xE9bergement m\xE9dicalis\xE9 pour personnes \xE2g\xE9es",
+  "8710B": "H\xE9bergement m\xE9dicalis\xE9 pour enfants handicap\xE9s",
+  "8710C": "H\xE9bergement m\xE9dicalis\xE9 pour adultes handicap\xE9s et autre h\xE9bergement m\xE9dicalis\xE9",
+  "8720A": "H\xE9bergement social pour handicap\xE9s mentaux et malades mentaux",
+  "8720B": "H\xE9bergement social pour toxicomanes",
+  "8730A": "H\xE9bergement social pour personnes \xE2g\xE9es",
+  "8730B": "H\xE9bergement social pour handicap\xE9s physiques",
+  // Action sociale sans hébergement
+  "8810A": "Aide \xE0 domicile",
+  "8810B": "Accueil ou accompagnement sans h\xE9bergement d'adultes handicap\xE9s ou de personnes \xE2g\xE9es",
+  "8810C": "Aide par le travail",
+  "8891A": "Accueil de jeunes enfants",
+  "8891B": "Accueil ou accompagnement sans h\xE9bergement d'enfants handicap\xE9s",
+  "8899A": "Autre accueil ou accompagnement sans h\xE9bergement d'enfants et d'adolescents",
+  "8899B": "Action sociale sans h\xE9bergement n.c.a.",
+  // Pharmacies et commerce de matériel médical
+  "4773Z": "Commerce de d\xE9tail de produits pharmaceutiques en magasin sp\xE9cialis\xE9",
+  "4774Z": "Commerce de d\xE9tail d'articles m\xE9dicaux et orthop\xE9diques en magasin sp\xE9cialis\xE9"
+};
+var NAF_LABOS = ["8690B"];
+var NAF_PHARMACIES = ["4773Z"];
+var NAF_EHPAD = ["8710A", "8730A"];
+var NAF_MEDECINE_VILLE = [
+  "8621Z",
+  "8622A",
+  "8622B",
+  "8622C"
+];
+function libelleNaf(code) {
+  return NAF_SANTE[code];
+}
+
+// src/core/query-metadata.ts
+var SOURCE_NOTE = {
+  centroide_commune_ameli: "Coordonn\xE9es Ameli = centro\xEFde commune (~3 km moyenne). Adapt\xE9 \xE0 l'analyse de densit\xE9 m\xE9dicale, pas au g\xE9ocodage adresse.",
+  lambert93_natif_finess: "FINESS DREES (sync bimestrielle) \u2014 r\xE9f\xE9rentiel peut avoir 1-2 mois de retard sur le terrain pour les structures \xE9mergentes (CPTS r\xE9centes, MSP en agr\xE9ment). Cross-check ARS / Service Public si n\xE9cessaire.",
+  centroide_commune_ans: "Coordonn\xE9es RPPS/ANS = centro\xEFde commune (~3 km moyenne). Source : Annuaire Sant\xE9 ANS \u2014 Licence Ouverte v2.0. Pour une pr\xE9cision adresse, croiser num_finess avec etablissement_by_finess.",
+  structure_finess: "Liste rattach\xE9e \xE0 un FINESS site. Le mode_exercice r\xE9v\xE8le la nature du lien (lib\xE9ral / salari\xE9). Couverture RPPS quand le PS l'a d\xE9clar\xE9 ; salari\xE9s CH/CHU/cliniques bien couverts."
+};
+var HAVERSINE_NOTE = "Distance calcul\xE9e en vol d'oiseau (haversine PostGIS). Pour la distance routi\xE8re, croiser avec un service externe (OSRM, ORS).";
+function buildMetadata(precision, withDistance) {
+  const notes = [SOURCE_NOTE[precision]];
+  const result = { geo_precision: precision, notes };
+  if (withDistance) {
+    result.distance_type = "haversine_postgis";
+    notes.push(HAVERSINE_NOTE);
+  }
+  return result;
+}
+var finessRadiusMetadata = () => buildMetadata("lambert93_natif_finess", true);
+var finessByCategorieMetadata = () => buildMetadata("lambert93_natif_finess", false);
+var rppsRadiusMetadata = () => buildMetadata("centroide_commune_ans", true);
+var rppsDeptMetadata = () => buildMetadata("centroide_commune_ans", false);
+var rppsEtablissementMetadata = () => buildMetadata("structure_finess", false);
+var anonClient = null;
+var untypedAnonClient = null;
+function requireEnv(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    throw new Error(
+      `[france-data-mcp] Missing required environment variable: ${name}. Set it in .env.local for local dev or in GitHub Secrets for CI/Actions.`
+    );
+  }
+  if (value === "") {
+    throw new Error(
+      `[france-data-mcp] Environment variable ${name} is set but empty. Likely a misconfigured GitHub Secret (renamed/unscoped) or an empty line in .env.local.`
+    );
+  }
+  return value;
+}
+function getAnonClient() {
+  if (!anonClient) {
+    const url = requireEnv("SUPABASE_URL");
+    const key = requireEnv("SUPABASE_ANON_KEY");
+    anonClient = createClient(url, key, {
+      auth: { persistSession: false }
+    });
+  }
+  return anonClient;
+}
+function getUntypedAnonClient() {
+  if (!untypedAnonClient) {
+    const url = requireEnv("SUPABASE_URL");
+    const key = requireEnv("SUPABASE_ANON_KEY");
+    untypedAnonClient = createClient(url, key, { auth: { persistSession: false } });
+  }
+  return untypedAnonClient;
+}
+
+// src/sante/db-helpers.ts
+var DEFAULT_LIMIT = 100;
+var MAX_LIMIT = 500;
+var MAX_OFFSET = 1e5;
+var RADIUS_MIN_KM = 0.1;
+var RADIUS_MAX_KM = 50;
+function clampLimit(limit) {
+  if (limit === void 0) return DEFAULT_LIMIT;
+  if (limit < 1 || limit > MAX_LIMIT) {
+    throw new RangeError(
+      `[france-data-mcp] limit must be between 1 and ${MAX_LIMIT}, got ${limit}`
+    );
+  }
+  return limit;
+}
+function clampOffset(offset) {
+  if (offset === void 0) return 0;
+  if (!Number.isFinite(offset) || offset < 0 || offset > MAX_OFFSET) {
+    throw new RangeError(
+      `[france-data-mcp] offset must be between 0 and ${MAX_OFFSET}, got ${offset}`
+    );
+  }
+  return Math.floor(offset);
+}
+function validateRadiusKm(radiusKm) {
+  if (!Number.isFinite(radiusKm) || radiusKm < RADIUS_MIN_KM || radiusKm > RADIUS_MAX_KM) {
+    throw new RangeError(
+      `[france-data-mcp] radiusKm must be in [${RADIUS_MIN_KM}, ${RADIUS_MAX_KM}], got ${radiusKm}`
+    );
+  }
+}
+function validateCoords(lat, lon) {
+  if (!Number.isFinite(lat) || lat < -90 || lat > 90) {
+    throw new RangeError(`[france-data-mcp] lat must be in [-90, 90], got ${lat}`);
+  }
+  if (!Number.isFinite(lon) || lon < -180 || lon > 180) {
+    throw new RangeError(`[france-data-mcp] lon must be in [-180, 180], got ${lon}`);
+  }
+}
+function formatRpcError(rpc, error) {
+  const code = error.code ? ` (${error.code})` : "";
+  const hint = error.hint ? ` \u2014 hint: ${error.hint}` : "";
+  const details = error.details ? ` \u2014 details: ${error.details}` : "";
+  return `[france-data-mcp] ${rpc}${code}: ${error.message}${details}${hint}`;
+}
+function trimOrNull(s) {
+  if (s === null || s === void 0) return null;
+  const trimmed = s.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function expectRpcRows(rpc, data) {
+  if (data === null || data === void 0) {
+    throw new Error(
+      `[france-data-mcp] ${rpc}: RPC contract violation \u2014 supabase-js returned no error but data is ${data === null ? "null" : "undefined"}. Expected an array (possibly empty). Investigate RPC name, schema cache, or supabase-js version.`
+    );
+  }
+  if (!Array.isArray(data)) {
+    throw new Error(
+      `[france-data-mcp] ${rpc}: RPC contract violation \u2014 expected array, got ${typeof data}. Likely an RPC signature mismatch.`
+    );
+  }
+  return data;
+}
+
+// src/sante/finess-db.ts
+function familiesToCodes(familles) {
+  if (!familles || familles.length === 0) return [];
+  return familles.flatMap((f) => [...FINESS_FAMILY_CODES[f]]);
+}
+async function getFinessInRadius(input) {
+  const limit = clampLimit(input.limit);
+  validateCoords(input.center.lat, input.center.lon);
+  validateRadiusKm(input.radiusKm);
+  const supabase = getAnonClient();
+  const { data, error } = await supabase.rpc("finess_in_radius", {
+    p_lat: input.center.lat,
+    p_lon: input.center.lon,
+    p_radius_meters: input.radiusKm * 1e3,
+    p_codes: familiesToCodes(input.familles),
+    p_limit: limit + 1
+    // +1 to detect truncation
+  });
+  if (error) {
+    throw new Error(formatRpcError("finess_in_radius", error));
+  }
+  return buildFinessQueryResult("finess_in_radius", data, limit, finessRadiusMetadata());
+}
+async function getFinessByCategorie(input) {
+  const limit = clampLimit(input.limit);
+  const supabase = getAnonClient();
+  const { data, error } = await supabase.rpc("finess_by_categorie", {
+    p_codes: [...FINESS_FAMILY_CODES[input.famille]],
+    p_departement: input.departement ?? null,
+    p_code_insee: input.code_insee ?? null,
+    p_limit: limit + 1
+  });
+  if (error) {
+    throw new Error(formatRpcError("finess_by_categorie", error));
+  }
+  return buildFinessQueryResult("finess_by_categorie", data, limit, finessByCategorieMetadata());
+}
+async function getFinessByNumFiness(numFiness) {
+  if (!/^\d{9}$/.test(numFiness)) {
+    throw new Error(`[france-data-mcp] num_finess must be 9 digits, got "${numFiness}"`);
+  }
+  const supabase = getAnonClient();
+  const { data, error } = await supabase.rpc("finess_by_num_finess", {
+    p_num_finess: numFiness
+  });
+  if (error) {
+    throw new Error(formatRpcError("finess_by_num_finess", error));
+  }
+  const rows = expectRpcRows("finess_by_num_finess", data);
+  if (rows.length > 1) {
+    console.warn(
+      `[france-data-mcp] finess_by_num_finess(${numFiness}): RPC returned ${rows.length} rows (expected \u2264 1) \u2014 picking the first. Investigate finess table for duplicate num_finess.`
+    );
+  }
+  const first = rows[0];
+  if (!first) {
+    return lookupNotFound(
+      numFiness,
+      `Num\xE9ro FINESS "${numFiness}" introuvable dans la base DREES (derni\xE8re sync bimestrielle). Causes possibles : num\xE9ro inexistant, structure tr\xE8s r\xE9cente non encore propag\xE9e par DREES (latence ~1-2 mois), erreur de saisie. Pour structures \xE9mergentes (CPTS, MSP r\xE9centes), cross-check avec ARS r\xE9gionale ou Service Public.`
+    );
+  }
+  return lookupFound(toFinessResult(first));
+}
+function buildFinessQueryResult(rpc, data, limit, metadata) {
+  const rows = expectRpcRows(rpc, data);
+  const truncated = rows.length > limit;
+  const sliced = truncated ? rows.slice(0, limit) : rows;
+  return {
+    count: sliced.length,
+    truncated,
+    results: sliced.map(toFinessResult),
+    query_metadata: metadata
+  };
+}
+function toFinessResult(row) {
+  const coords = row.geom ? { lat: row.geom.coordinates[1] ?? 0, lon: row.geom.coordinates[0] ?? 0 } : null;
+  return {
+    num_finess: row.num_finess,
+    raison_sociale: row.raison_sociale,
+    categorie: {
+      code: row.categorie_code,
+      libelle: row.categorie_libelle,
+      famille: finessFamille(row.categorie_code)
+    },
+    adresse: {
+      voie: row.voie,
+      code_postal: trimOrNull(row.code_postal),
+      ville: row.ville,
+      code_departement: trimOrNull(row.code_departement),
+      code_insee: row.code_insee.trim()
+    },
+    coords,
+    distance_km: metersToKm(row.distance_meters),
+    telephone: trimOrNull(row.telephone),
+    email: row.email
+  };
+}
+
+// src/territoire/dept-codes.ts
+function isValidDept(dept) {
+  if (dept === "2A" || dept === "2B") return true;
+  if (/^\d{2}$/.test(dept)) return dept !== "20";
+  if (/^(97[1-8]|98[4-8])$/.test(dept)) return true;
+  return false;
+}
+function assertValidDept(dept) {
+  if (isValidDept(dept)) return;
+  throw new RangeError(`[france-data-mcp] departement must be a valid INSEE code, got "${dept}"`);
+}
+
+// src/sante/rpps-types.ts
+var RPPS_MODE_EXERCICE = {
+  LIBERAL: "L",
+  SALARIE: "S",
+  MIXTE: "M",
+  REMPLACANT: "R",
+  AUTRE: "A",
+  BENEVOLE: "B"
+};
+var RPPS_CGU_NOTICE = "Source : Annuaire Sant\xE9, Agence du Num\xE9rique en Sant\xE9 (ANS) \u2014 Licence Ouverte v2.0";
+
+// src/sante/rpps-db.ts
+var CATEGORIE_CODE_CIVIL = "C";
+var CATEGORIE_CODES_DEFAUT = Object.freeze([
+  CATEGORIE_CODE_CIVIL
+]);
+async function getRppsInRadius(input) {
+  const limit = clampLimit(input.limit);
+  validateCoords(input.center.lat, input.center.lon);
+  validateRadiusKm(input.radiusKm);
+  const supabase = getUntypedAnonClient();
+  const { data, error } = await supabase.rpc("rpps_in_radius", {
+    p_lat: input.center.lat,
+    p_lon: input.center.lon,
+    p_radius_meters: input.radiusKm * 1e3,
+    p_profession_codes: input.professionCodes ?? [],
+    p_savoir_faire_codes: input.savoirFaireCodes ?? [],
+    p_mode_exercice_codes: input.modeExerciceCodes ?? [],
+    p_categorie_codes: input.categorieCodes ?? [],
+    p_limit: limit + 1
+  });
+  if (error) throw new Error(formatRpcError("rpps_in_radius", error));
+  return buildQueryResult("rpps_in_radius", data, limit, rppsRadiusMetadata());
+}
+async function getRppsParSpecialiteDept(input) {
+  const limit = clampLimit(input.limit);
+  const offset = clampOffset(input.offset);
+  assertValidDept(input.departement);
+  const supabase = getUntypedAnonClient();
+  const categorieCodes = input.categorieCodes && input.categorieCodes.length > 0 ? input.categorieCodes : [...CATEGORIE_CODES_DEFAUT];
+  const { data, error } = await supabase.rpc("rpps_par_specialite_dept", {
+    p_departement: input.departement,
+    p_profession_code: input.professionCode ?? null,
+    p_savoir_faire_code: input.savoirFaireCode ?? null,
+    p_mode_exercice_code: input.modeExerciceCode ?? null,
+    p_categorie_codes: categorieCodes,
+    p_limit: limit + 1,
+    p_offset: offset
+  });
+  if (error) throw new Error(formatRpcError("rpps_par_specialite_dept", error));
+  return buildQueryResult("rpps_par_specialite_dept", data, limit, rppsDeptMetadata());
+}
+async function getRppsDansEtablissement(input) {
+  const limit = clampLimit(input.limit);
+  const numFiness = input.numFiness.trim();
+  if (!/^\d{9}$/.test(numFiness)) {
+    throw new RangeError(
+      `[france-data-mcp] num_finess invalide "${input.numFiness}" \u2014 attendu 9 chiffres (FINESS site).`
+    );
+  }
+  const supabase = getUntypedAnonClient();
+  const { data, error } = await supabase.rpc("rpps_dans_etablissement", {
+    p_num_finess: numFiness,
+    p_categorie_codes: input.categorieCodes ?? [],
+    p_limit: limit + 1
+  });
+  if (error) throw new Error(formatRpcError("rpps_dans_etablissement", error));
+  const rows = expectRpcRows("rpps_dans_etablissement", data);
+  const truncated = rows.length > limit;
+  const sliced = truncated ? rows.slice(0, limit) : rows;
+  return {
+    count: sliced.length,
+    truncated,
+    results: sliced.map(toCompactResult),
+    query_metadata: rppsEtablissementMetadata()
+  };
+}
+async function getRppsById(rppsId) {
+  const trimmed = rppsId.trim();
+  if (!/^\d{11,12}$/.test(trimmed)) {
+    throw new RangeError(
+      `[france-data-mcp] rpps_id invalide "${rppsId}" \u2014 attendu 11 ou 12 chiffres (IDNPS national, format ANS \u2014 pr\xE9fixe "81" optionnel pour les IDs \xE9mis depuis 2020 = 12 chars, sans pr\xE9fixe = 11 chars).`
+    );
+  }
+  const supabase = getUntypedAnonClient();
+  const { data, error } = await supabase.rpc("rpps_lookup_by_id", {
+    p_rpps_id: trimmed
+  });
+  if (error) throw new Error(formatRpcError("rpps_lookup_by_id", error));
+  const rows = expectRpcRows("rpps_lookup_by_id", data);
+  return rows.map(toLookupResult);
+}
+function buildQueryResult(rpc, data, limit, metadata) {
+  const rows = expectRpcRows(rpc, data);
+  const truncated = rows.length > limit;
+  const sliced = truncated ? rows.slice(0, limit) : rows;
+  return {
+    count: sliced.length,
+    truncated,
+    results: sliced.map(toResult),
+    query_metadata: metadata
+  };
+}
+function toResult(row) {
+  const lat = row.geom?.coordinates[1];
+  const lon = row.geom?.coordinates[0];
+  const coords = typeof lat === "number" && typeof lon === "number" ? { lat, lon } : null;
+  return {
+    id: row.id,
+    rpps_id: row.rpps_id,
+    identite: {
+      nom: row.nom,
+      prenom: row.prenom,
+      civilite: row.civilite
+    },
+    profession: { code: row.profession_code, libelle: row.profession_libelle },
+    savoir_faire: { code: row.savoir_faire_code, libelle: row.savoir_faire_libelle },
+    mode_exercice: { code: row.mode_exercice_code, libelle: row.mode_exercice_libelle },
+    categorie: { code: row.categorie_code, libelle: row.categorie_libelle },
+    structure: {
+      num_finess: row.num_finess,
+      num_finess_ej: row.num_finess_ej,
+      siret: row.siret,
+      raison_sociale: row.raison_sociale
+    },
+    adresse: {
+      voie: row.adresse,
+      // CHAR(N) Postgres pad avec espaces — trim systématique pour ne pas
+      // leak `"08 "` côté caller (cohérent finess-db.ts / ameli-db.ts).
+      code_postal: trimOrNull(row.code_postal),
+      ville: row.ville,
+      code_departement: trimOrNull(row.code_departement),
+      code_insee: trimOrNull(row.code_insee)
+    },
+    coords,
+    distance_km: metersToKm(row.distance_meters),
+    telephone: row.telephone
+  };
+}
+function toCompactResult(row) {
+  return {
+    id: row.id,
+    rpps_id: row.rpps_id,
+    identite: { nom: row.nom, prenom: row.prenom, civilite: row.civilite },
+    profession: { code: row.profession_code, libelle: row.profession_libelle },
+    savoir_faire: { code: row.savoir_faire_code, libelle: row.savoir_faire_libelle },
+    mode_exercice: { code: row.mode_exercice_code, libelle: row.mode_exercice_libelle },
+    categorie: { code: row.categorie_code, libelle: row.categorie_libelle },
+    structure: {
+      num_finess: row.num_finess,
+      num_finess_ej: row.num_finess_ej,
+      siret: null,
+      raison_sociale: row.raison_sociale
+    },
+    adresse: {
+      voie: null,
+      code_postal: null,
+      ville: null,
+      code_departement: null,
+      code_insee: null
+    },
+    coords: null,
+    distance_km: null,
+    telephone: row.telephone
+  };
+}
+function toLookupResult(row) {
+  return {
+    ...toResult(row),
+    identifiant_pp: row.identifiant_pp,
+    siren: row.siren,
+    email: row.email
+  };
+}
+
+// src/sante/ans-fhir.ts
+var ANS_FHIR_DEFAULT_BASE = "https://gateway.api.esante.gouv.fr/fhir/v2";
+var ANS_AUTH_HEADER = "ESANTE-API-KEY";
+var IDNPS_SYSTEM = "urn:oid:1.2.250.1.71.4.2.1";
+var FETCH_TIMEOUT_MS2 = 6e4;
+function getAnsFhirApiKey() {
+  const raw = process.env.ANS_FHIR_API_KEY;
+  if (!raw) return null;
+  const cleaned = raw.trim().replace(/^["']|["']$/g, "");
+  return cleaned === "" ? null : cleaned;
+}
+function getAnsFhirBaseUrl() {
+  const raw = process.env.ANS_FHIR_BASE_URL?.trim();
+  return raw && raw !== "" ? raw.replace(/\/+$/, "") : ANS_FHIR_DEFAULT_BASE;
+}
+async function lookupPractitionerByRpps(rppsId) {
+  const apiKey = getAnsFhirApiKey();
+  if (!apiKey) {
+    return {
+      found: false,
+      status: "no_key",
+      message: "ESANTE-API-KEY non configur\xE9e c\xF4t\xE9 serveur. Fallback FHIR ANS indisponible \u2014 s'appuyer sur la DB locale (snapshot mensuel J-30 max)."
+    };
+  }
+  const trimmed = rppsId.trim();
+  if (trimmed === "" || !/^\d{11,12}$/.test(trimmed)) {
+    console.warn(
+      `[france-data-mcp] ANS FHIR lookup skipped \u2014 rpps_id "${rppsId}" rejet\xE9 par la garde format /^\\d{11,12}$/.`
+    );
+    return {
+      found: false,
+      status: "invalid_format",
+      message: `rpps_id "${rppsId}" invalide \u2014 format IDNPS attendu : 11 ou 12 chiffres.`
+    };
+  }
+  const baseUrl = getAnsFhirBaseUrl();
+  const url = `${baseUrl}/Practitioner?identifier=${encodeURIComponent(IDNPS_SYSTEM)}|${encodeURIComponent(trimmed)}`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS2);
+  let bundle;
+  try {
+    bundle = await fetchJson(url, {
+      headers: {
+        [ANS_AUTH_HEADER]: apiKey,
+        Accept: "application/fhir+json"
+      },
+      signal: controller.signal
+    });
+  } catch (err) {
+    const httpStatus = err instanceof HttpError ? err.status : null;
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const detail = httpStatus !== null ? `HTTP ${httpStatus}` : `network/parse error: ${errMsg}`;
+    const logFn = httpStatus === 404 ? console.warn : console.error;
+    logFn(`[france-data-mcp] ANS FHIR lookup terminated for rpps=${trimmed} \u2014 ${detail}`);
+    if (httpStatus === 404) {
+      return {
+        found: false,
+        status: "not_found",
+        message: `IDNPS ${trimmed} introuvable c\xF4t\xE9 ANS FHIR (HTTP 404).`
+      };
+    }
+    return {
+      found: false,
+      status: "api_error",
+      message: `ANS FHIR lookup failed for rpps=${trimmed} \u2014 ${detail}. Retry recommand\xE9.`
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+  const entries = bundle.entry ?? [];
+  if (entries.length === 0) {
+    return {
+      found: false,
+      status: "not_found",
+      message: `IDNPS ${trimmed} introuvable c\xF4t\xE9 ANS FHIR (Bundle vide).`
+    };
+  }
+  const resource = entries[0]?.resource;
+  if (!resource || resource.resourceType !== "Practitioner") {
+    console.warn(
+      `[france-data-mcp] ANS FHIR Practitioner attendu mais resource=${resource?.resourceType ?? "null"} pour rpps=${trimmed} \u2014 r\xE9ponse incoh\xE9rente`
+    );
+    return {
+      found: false,
+      status: "api_error",
+      message: `ANS FHIR a renvoy\xE9 un payload incoh\xE9rent pour ${trimmed} (resourceType inattendu).`
+    };
+  }
+  return { found: true, practitioner: mapPractitioner(resource, trimmed) };
+}
+function mapPractitioner(resource, expectedRpps) {
+  const ansInternalId = resource.id ?? "";
+  const idnps = resource.identifier?.find(
+    (id) => id.system === IDNPS_SYSTEM || id.type?.coding?.some((c) => c.code === "IDNPS")
+  );
+  const idnpsValue = idnps?.value?.trim();
+  if (!idnpsValue) {
+    console.warn(
+      `[france-data-mcp] ANS FHIR Practitioner (id=${resource.id ?? "?"}) sans IDNPS exploitable \u2014 fallback sur la valeur URL "${expectedRpps}"`
+    );
+  }
+  const rpps_id = idnpsValue || expectedRpps;
+  const officialName = resource.name?.find((n) => n.use === "official") ?? resource.name?.[0];
+  const family = officialName?.family?.trim() ?? "";
+  const given = officialName?.given?.[0]?.trim() ?? "";
+  const civilite = officialName?.prefix?.[0]?.trim() ?? null;
+  return {
+    ans_internal_id: ansInternalId,
+    rpps_id,
+    civilite,
+    nom: family,
+    prenom: given,
+    active: typeof resource.active === "boolean" ? resource.active : null,
+    source: "ans_fhir"
+  };
+}
+
+// src/sante/index.ts
+var SANTE_VERSION = "0.5.1";
+
+export { FINESS_CATEGORIES, FINESS_EHPAD, FINESS_FAMILY_CODES, FINESS_HOPITAUX, FINESS_LABOS, FINESS_MSP_CPTS, FINESS_PHARMACIES, NAF_EHPAD, NAF_LABOS, NAF_MEDECINE_VILLE, NAF_PHARMACIES, NAF_SANTE, RPPS_CGU_NOTICE, RPPS_MODE_EXERCICE, SANTE_VERSION, TERRITOIRE_VERSION, ensureAnnuaireAmeli, finessFamille, geocode, geocodeMany, getAnsFhirApiKey, getAnsFhirBaseUrl, getCommuneByCode, getEntrepriseBySiren, getFinessByCategorie, getFinessByNumFiness, getFinessInRadius, getInseeApiKey, getRppsById, getRppsDansEtablissement, getRppsInRadius, getRppsParSpecialiteDept, haversineDistance, libelleCategorieFiness, libelleNaf, loadFiness, loadProfessionnels, lookupPractitionerByRpps, lookupSirenViaInsee, reverseGeocode, searchCommunes, searchEntreprises, searchEtablissementsFiness, streamProfessionnels };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map