mcp-databnf 1.0.0

package/dist/index.js

@@ -0,0 +1,2265 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/version.ts
+var PKG_VERSION = "1.0.0";
+var REPO_URL = "https://github.com/smeet666/mcp-databnf";
+
+// src/config.ts
+var LOG_LEVELS = ["silent", "error", "info", "debug"];
+var MIN_ALLOWED_INTERVAL_MS = 3e3;
+var MAX_ALLOWED_INTERVAL_MS = 12e4;
+var DEFAULT_INTERVAL_MS = 3e3;
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_USER_AGENT = `mcp-databnf/${PKG_VERSION} (+${REPO_URL})`;
+function createLogger(level) {
+  const rank = LOG_LEVELS.indexOf(level);
+  const write = (at, message) => {
+    if (rank === 0 || LOG_LEVELS.indexOf(at) > rank) return;
+    process.stderr.write(`[mcp-databnf] ${at}: ${message}
+`);
+  };
+  return {
+    debug: (m) => write("debug", m),
+    info: (m) => write("info", m),
+    // A warning goes out at the error level so it survives the default
+    // setting: a caller has to know that rows were dropped.
+    warn: (m) => write("error", m),
+    error: (m) => write("error", m)
+  };
+}
+function readInteger(env, name, fallback, min, max) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    process.stderr.write(
+      `[mcp-databnf] error: ${name}="${raw}" is not a whole number; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  if (value < min || value > max) {
+    process.stderr.write(
+      `[mcp-databnf] error: ${name}=${value} is outside ${min}..${max}; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  return value;
+}
+function loadConfig(env = process.env) {
+  const level = env.BNF_LOG_LEVEL;
+  const logLevel = level && LOG_LEVELS.includes(level) ? level : "error";
+  if (level && !LOG_LEVELS.includes(level)) {
+    process.stderr.write(
+      `[mcp-databnf] error: BNF_LOG_LEVEL="${level}" is not one of ${LOG_LEVELS.join(", ")}; using error.
+`
+    );
+  }
+  const custom = env.BNF_USER_AGENT?.trim();
+  return {
+    // A caller who wants to be recognised may say who they are, and the
+    // contact address stays attached: the BnF has to be able to reach a human
+    // about traffic it did not expect.
+    userAgent: custom ? `${custom} ${DEFAULT_USER_AGENT}` : DEFAULT_USER_AGENT,
+    minIntervalMs: readInteger(
+      env,
+      "BNF_MIN_INTERVAL_MS",
+      DEFAULT_INTERVAL_MS,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: readInteger(env, "BNF_TIMEOUT_MS", DEFAULT_TIMEOUT_MS, 1e3, 3e5),
+    maxRetries: readInteger(env, "BNF_MAX_RETRIES", 3, 0, 8),
+    cacheTtlMs: readInteger(env, "BNF_CACHE_TTL_MS", 9e5, 0, 864e5),
+    cacheMaxEntries: readInteger(env, "BNF_CACHE_MAX_ENTRIES", 200, 1, 5e3),
+    logLevel
+  };
+}
+
+// src/errors.ts
+var BnfError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "BnfError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var notFound = (message, details) => new BnfError("not_found", message, details);
+var invalidInput = (message, hint) => new BnfError("invalid_input", message, hint ? { hint } : {});
+var rateLimited = (message, details) => new BnfError("rate_limited", message, {
+  hint: "Wait a moment and ask again. This says nothing about whether the BnF describes what you asked for.",
+  ...details
+});
+var parseFailure = (message, details) => new BnfError("parse_failure", message, {
+  hint: "data.bnf.fr may have changed how it answers. Please report this at https://github.com/smeet666/mcp-databnf/issues with the arguments you used.",
+  ...details
+});
+var networkError = (message, details) => new BnfError("network_error", message, details);
+var timeout = (message, details) => new BnfError("timeout", message, details);
+
+// src/bnf/cache.ts
+var Cache = class {
+  constructor(ttlMs, maxEntries) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+  }
+  ttlMs;
+  maxEntries;
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt <= Date.now()) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+    return { value: entry.value, retrievedAt: entry.retrievedAt };
+  }
+  set(key, value, retrievedAt) {
+    if (this.ttlMs <= 0) return;
+    this.entries.delete(key);
+    this.entries.set(key, { value, expiresAt: Date.now() + this.ttlMs, retrievedAt });
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next();
+      if (oldest.done) break;
+      this.entries.delete(oldest.value);
+    }
+  }
+  get size() {
+    return this.entries.size;
+  }
+};
+
+// src/bnf/endpoint.ts
+var SPARQL_ENDPOINT = "https://data.bnf.fr/sparql";
+var ALLOWED_HOST = "data.bnf.fr";
+var GALLICA_HOST = "gallica.bnf.fr";
+function assertRequestable(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw refusal(`mcp-databnf refuses to request "${url}": it is not an address.`);
+  }
+  const host = parsed.hostname.toLowerCase().replace(/\.$/, "");
+  if (host !== ALLOWED_HOST) {
+    throw refusal(
+      `mcp-databnf requests ${ALLOWED_HOST} and nothing else; "${host}" was refused. Gallica in particular is described from the catalogue and never read.`
+    );
+  }
+}
+var refusal = (message) => new BnfError("network_error", message, {
+  hint: "This server reads the BnF catalogue at data.bnf.fr. It holds no licence to read the digitised contents, so it does not follow an address that leaves that host."
+});
+function isGallicaAddress(address) {
+  try {
+    const host = new URL(address).hostname.toLowerCase().replace(/\.$/, "");
+    return host === GALLICA_HOST || host.endsWith(`.${GALLICA_HOST}`);
+  } catch {
+    return false;
+  }
+}
+var PREFIXES = {
+  foaf: "http://xmlns.com/foaf/0.1/",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  owl: "http://www.w3.org/2002/07/owl#",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  dcterms: "http://purl.org/dc/terms/",
+  bio: "http://vocab.org/bio/0.1/",
+  bnf: "http://data.bnf.fr/ontology/bnf-onto/",
+  bibo: "http://purl.org/ontology/bibo/",
+  isni: "http://isni.org/ontology#",
+  /** RDA group 2 elements, which carry the biographical fields. */
+  rdag2: "http://rdvocab.info/ElementsGr2/",
+  /** RDA elements, which carry the bibliographic fields. */
+  rdae: "http://rdvocab.info/Elements/",
+  /** RDA relationships between work, expression, manifestation and item. */
+  rdarel: "http://rdvocab.info/RDARelationshipsWEMI/",
+  /** The FRBR classes data.bnf.fr types its entities with. */
+  rdafrbr: "http://rdvocab.info/uri/schema/FRBRentitiesRDA/"
+};
+var PREFIX_BLOCK = Object.entries(PREFIXES).map(([name, iri]) => `PREFIX ${name}: <${iri}>`).join("\n");
+var publicPageFor = (entityIri) => entityIri.replace(/#.*$/, "").replace(/^http:/, "https:");
+
+// src/bnf/http.ts
+var RETRYABLE = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var PUSH_BACK = /* @__PURE__ */ new Set([429, 503]);
+var LONGEST_WAIT_MS = 3e4;
+var RETRIES_AFTER_SILENCE = 1;
+var MAX_REDIRECTS = 2;
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return null;
+  return Math.max(0, at - now);
+}
+function backoffMs(attempt) {
+  const base = Math.min(16e3, 1e3 * 2 ** attempt);
+  return base + Math.floor(Math.random() * 500);
+}
+function readEngineError(body) {
+  const match = /^Virtuoso\s+(\w+)\s+Error\s+([\s\S]*)$/.exec(body.trim());
+  if (!match) return null;
+  const state = match[1] ?? "";
+  const text2 = (match[2] ?? "").split("\n")[0]?.trim() ?? "";
+  return { kind: state === "37000" ? "compile" : "runtime", text: text2 };
+}
+async function postOnce(options, signal) {
+  assertRequestable(SPARQL_ENDPOINT);
+  const doFetch = options.fetchImpl ?? fetch;
+  const form = new URLSearchParams();
+  form.set("query", options.query);
+  form.set("format", "application/sparql-results+json");
+  let target = SPARQL_ENDPOINT;
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+    const response = await doFetch(target, {
+      method: "POST",
+      signal,
+      redirect: "manual",
+      headers: {
+        "user-agent": options.userAgent,
+        accept: "application/sparql-results+json",
+        "content-type": "application/x-www-form-urlencoded"
+      },
+      body: form.toString()
+    });
+    const location = response.headers.get("location");
+    if (response.status >= 300 && response.status < 400 && location !== null) {
+      const next = new URL(location, target).toString();
+      assertRequestable(next);
+      target = next;
+      continue;
+    }
+    return {
+      status: response.status,
+      headers: response.headers,
+      body: await response.text(),
+      ok: response.ok
+    };
+  }
+  throw networkError(`data.bnf.fr redirected this request more than ${MAX_REDIRECTS} times.`, {
+    url: SPARQL_ENDPOINT
+  });
+}
+async function runQuery(options) {
+  const { timeoutMs, maxRetries, limiter, logger } = options;
+  let lastError = null;
+  let askedWaitMs = 0;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    if (askedWaitMs > 0) {
+      logger.debug(`waiting ${askedWaitMs}ms, as asked`);
+      await new Promise((resolve) => setTimeout(resolve, askedWaitMs));
+      askedWaitMs = 0;
+    }
+    await limiter.beforeRequest();
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      logger.debug(`POST ${SPARQL_ENDPOINT} (${options.query.length} characters)`);
+      const response = await postOnce(options, controller.signal);
+      if (response.ok) {
+        let parsed;
+        try {
+          parsed = parseResults(response.body);
+        } catch (error) {
+          limiter.pushBack();
+          throw error;
+        }
+        limiter.succeeded();
+        return parsed;
+      }
+      if (RETRYABLE.has(response.status)) limiter.pushBack();
+      if (PUSH_BACK.has(response.status)) {
+        const asked = parseRetryAfter(response.headers.get("retry-after"));
+        if (asked !== null && asked > LONGEST_WAIT_MS) {
+          throw rateLimited(
+            `data.bnf.fr asked this client to wait ${Math.round(asked / 1e3)} seconds (HTTP ${response.status}).`,
+            { url: SPARQL_ENDPOINT, status: response.status }
+          );
+        }
+        if (attempt >= maxRetries) {
+          throw rateLimited(
+            `data.bnf.fr asked this client to slow down (HTTP ${response.status}).`,
+            {
+              url: SPARQL_ENDPOINT,
+              status: response.status
+            }
+          );
+        }
+        askedWaitMs = asked ?? backoffMs(attempt);
+        lastError = new Error(`HTTP ${response.status}`);
+        continue;
+      }
+      if (RETRYABLE.has(response.status) && attempt < maxRetries) {
+        lastError = new Error(`HTTP ${response.status}`);
+        askedWaitMs = backoffMs(attempt);
+        continue;
+      }
+      if (response.status === 400 || response.status === 422) {
+        const engine = readEngineError(response.body);
+        throw invalidInput(
+          `data.bnf.fr would not run this query${engine?.text ? `: ${engine.text}` : "."}`,
+          "Try fewer or plainer words. If this keeps happening with ordinary input, please report it."
+        );
+      }
+      throw networkError(`data.bnf.fr answered HTTP ${response.status}.`, {
+        url: SPARQL_ENDPOINT,
+        status: response.status
+      });
+    } catch (error) {
+      clearTimeout(deadline);
+      if (error instanceof Error && error.name === "BnfError") throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        lastError = error;
+        if (attempt >= Math.min(maxRetries, RETRIES_AFTER_SILENCE)) {
+          throw timeout(
+            `No answer from data.bnf.fr within ${timeoutMs}ms. A query spanning the whole catalogue can take longer than the service will spend on it.`,
+            { url: SPARQL_ENDPOINT }
+          );
+        }
+        askedWaitMs = backoffMs(attempt);
+        continue;
+      }
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= maxRetries) {
+        throw networkError(`Could not reach data.bnf.fr: ${lastError.message}`, {
+          url: SPARQL_ENDPOINT
+        });
+      }
+      askedWaitMs = backoffMs(attempt);
+      continue;
+    } finally {
+      clearTimeout(deadline);
+    }
+  }
+  throw networkError(
+    `Could not reach data.bnf.fr: ${lastError?.message ?? "no attempt was made"}`,
+    {
+      url: SPARQL_ENDPOINT
+    }
+  );
+}
+function parseResults(body) {
+  if (body.trim() === "") {
+    throw parseFailure(
+      "data.bnf.fr returned an empty body, which is what it does when it abandons a query part way through.",
+      { url: SPARQL_ENDPOINT }
+    );
+  }
+  const engine = readEngineError(body);
+  if (engine) {
+    if (engine.kind === "compile") {
+      throw invalidInput(
+        `data.bnf.fr could not read this query: ${engine.text}`,
+        "Try fewer or plainer words. If this keeps happening with ordinary input, please report it."
+      );
+    }
+    throw timeout(`data.bnf.fr started this query and gave it up: ${engine.text}`, {
+      url: SPARQL_ENDPOINT
+    });
+  }
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    throw parseFailure("data.bnf.fr answered with something that is not JSON.", {
+      url: SPARQL_ENDPOINT
+    });
+  }
+  if (typeof payload !== "object" || payload === null || !("results" in payload) || typeof payload.results !== "object" || !Array.isArray(payload.results?.bindings)) {
+    throw parseFailure("data.bnf.fr answered with JSON that is not a SPARQL result set.", {
+      url: SPARQL_ENDPOINT
+    });
+  }
+  return payload;
+}
+
+// src/bnf/sparql.ts
+function escapeLiteral(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, "");
+}
+var literal = (value) => `"${escapeLiteral(value)}"`;
+function toSearchWords(input) {
+  const cleaned = input.normalize("NFC").replace(/[‘’ʼ]/gu, "'").replace(/[^\p{L}\p{N}'-]+/gu, " ");
+  const words = [];
+  for (const raw of cleaned.split(" ")) {
+    const word = raw.replace(/^['-]+/u, "").replace(/['-]+$/u, "");
+    if (word === "") continue;
+    words.push(word.length > 60 ? word.slice(0, 60) : word);
+    if (words.length >= 12) break;
+  }
+  return words;
+}
+function containsAllWords(words) {
+  if (words.length === 0) {
+    throw invalidInput(
+      "No word to search for: the text held no letters or digits.",
+      "Write the words to look for, such as a surname or a title."
+    );
+  }
+  const clause = words.map((word) => `'${word.replace(/'/g, "''")}'`).join(" AND ");
+  return literal(clause);
+}
+var ARK_ID = /^c[bc][0-9a-z]{6,20}$/;
+var TEMP_WORK_ID = /^[0-9a-f]{32}$/;
+function parseEntityId(input) {
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    throw invalidInput("An identifier is required.");
+  }
+  const arkMatch = /(?:^|\/)ark:\/12148\/(c[bc][0-9a-z]+)/i.exec(trimmed);
+  const bare = arkMatch ? arkMatch[1] : trimmed.replace(/^#/, "").split(/[#?]/)[0];
+  const candidate = (bare ?? "").toLowerCase();
+  if (ARK_ID.test(candidate)) {
+    return {
+      kind: "ark",
+      id: candidate,
+      iri: `http://data.bnf.fr/ark:/12148/${candidate}#about`,
+      pageUrl: `https://data.bnf.fr/ark:/12148/${candidate}`
+    };
+  }
+  const tempMatch = /temp-work\/([0-9a-f]{32})/i.exec(trimmed);
+  const digest = (tempMatch?.[1] ?? candidate).toLowerCase();
+  if (TEMP_WORK_ID.test(digest)) {
+    return {
+      kind: "temp-work",
+      id: `temp-work/${digest}`,
+      iri: `http://data.bnf.fr/temp-work/${digest}/#about`,
+      pageUrl: `https://data.bnf.fr/temp-work/${digest}/`
+    };
+  }
+  throw invalidInput(`"${input}" is not a data.bnf.fr identifier.`, hintFor(trimmed));
+}
+var GALLICA_DOCUMENT = /^(?:bpt6k|btv1b|bd6t|cb32|btv1b)[0-9a-z]+$/i;
+var PAGE_ADDRESS = /data\.bnf\.fr\/(?:[a-z]{2}\/)?(\d{6,12})\/([a-z0-9_]+)/i;
+var GENERAL_HINT = "An identifier looks like 'cb119219976' for an established record, or 'temp-work/22d7f68c1a4bdd081ad7ca791fd3b730' for a provisional one. Take it from a search result rather than building one.";
+function hintFor(input) {
+  const page2 = PAGE_ADDRESS.exec(input);
+  if (page2) {
+    const name = (page2[2] ?? "").replace(/_/g, " ");
+    return `That is the readable address of a data.bnf.fr page, and ${page2[1]} in it is the record's FRBNF number rather than the identifier these tools take. Search for "${name}" with search_authors or search_works, and use the identifier the row carries.`;
+  }
+  const gallicaArk = /ark:\/12148\/([0-9a-z]+)/i.exec(input)?.[1] ?? input;
+  if (GALLICA_DOCUMENT.test(gallicaArk)) {
+    return "That is a Gallica identifier: it names a digitised document rather than a record in the catalogue, and these tools read the catalogue. Search for the work with search_works, then list_editions will give you the Gallica link alongside the edition it belongs to.";
+  }
+  return GENERAL_HINT;
+}
+var iriOf = (id) => `<${id.iri}>`;
+function boundedInteger(value, min, max, name) {
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    throw invalidInput(`'${name}' has to be a whole number.`);
+  }
+  if (value < min || value > max) {
+    throw invalidInput(`'${name}' has to be between ${min} and ${max}.`);
+  }
+  return value;
+}
+
+// src/bnf/queries.ts
+var TEXT_WINDOW = 400;
+var prefixed = (body) => `${PREFIX_BLOCK}
+${body.trim()}
+`;
+function searchAuthorsQuery(words, limit, offset) {
+  const take = boundedInteger(limit, 1, 50, "limit") + 1;
+  const skip = boundedInteger(offset, 0, 5e3, "offset");
+  return prefixed(`
+SELECT ?person ?name ?label ?birthYear ?deathYear ?role WHERE {
+  {
+    SELECT DISTINCT ?person WHERE {
+      {
+        SELECT DISTINCT ?person ?name WHERE {
+          ?person foaf:name ?name .
+          ?name bif:contains ${containsAllWords(words)} .
+        }
+        LIMIT ${TEXT_WINDOW}
+      }
+      ?person a foaf:Person .
+    }
+    ORDER BY ?person
+    LIMIT ${take} OFFSET ${skip}
+  }
+  OPTIONAL { ?person foaf:name ?name }
+  OPTIONAL { ?record foaf:focus ?person ; skos:prefLabel ?label }
+  OPTIONAL { ?person bnf:firstYear ?birthYear }
+  OPTIONAL { ?person bnf:lastYear ?deathYear }
+  OPTIONAL { ?person rdag2:biographicalInformation ?role }
+}`);
+}
+var MOST_TRIPLES = 2e3;
+function authorQuery(id) {
+  const person = iriOf(id);
+  return prefixed(`
+SELECT ?p ?o ?lang WHERE {
+  {
+    ${person} ?p ?o .
+    BIND(LANG(?o) AS ?lang)
+  }
+  UNION
+  {
+    ?record foaf:focus ${person} ; ?p ?o .
+    BIND(LANG(?o) AS ?lang)
+  }
+}
+LIMIT ${MOST_TRIPLES}`);
+}
+function searchWorksQuery(words, limit, offset) {
+  const take = boundedInteger(limit, 1, 50, "limit") + 1;
+  const skip = boundedInteger(offset, 0, 5e3, "offset");
+  return prefixed(`
+SELECT ?work ?title ?date ?status ?creator ?creatorName WHERE {
+  {
+    SELECT DISTINCT ?work WHERE {
+      {
+        SELECT DISTINCT ?work ?title WHERE {
+          ?work dcterms:title ?title .
+          ?title bif:contains ${containsAllWords(words)} .
+        }
+        LIMIT ${TEXT_WINDOW}
+      }
+      ?work a rdafrbr:Work .
+    }
+    ORDER BY ?work
+    LIMIT ${take} OFFSET ${skip}
+  }
+  OPTIONAL { ?work dcterms:title ?title }
+  OPTIONAL { ?work dcterms:date ?date }
+  OPTIONAL { ?work rdae:statusOfIdentification ?status }
+  OPTIONAL {
+    ?work dcterms:creator ?creator .
+    OPTIONAL { ?creator foaf:name ?creatorName }
+  }
+}`);
+}
+function workQuery(id) {
+  const work = iriOf(id);
+  return prefixed(`
+SELECT ?p ?o ?lang ?name WHERE {
+  ${work} ?p ?o .
+  BIND(LANG(?o) AS ?lang)
+  OPTIONAL { ?o foaf:name ?name }
+}
+LIMIT ${MOST_TRIPLES}`);
+}
+function editionsQuery(id, limit, offset) {
+  const work = iriOf(id);
+  const take = boundedInteger(limit, 1, 50, "limit") + 1;
+  const skip = boundedInteger(offset, 0, 5e3, "offset");
+  return prefixed(`
+SELECT ?edition ?title ?date ?year ?publisher ?place ?editionStatement
+       ?extent ?isbn ?note ?catalogue ?reproduction ?ocr WHERE {
+  {
+    SELECT DISTINCT ?edition WHERE {
+      ?edition rdarel:workManifested ${work} .
+    }
+    ORDER BY ?edition
+    LIMIT ${take} OFFSET ${skip}
+  }
+  OPTIONAL { ?edition dcterms:title ?title }
+  OPTIONAL { ?edition dcterms:date ?date }
+  OPTIONAL { ?edition bnf:firstYear ?year }
+  OPTIONAL { ?edition rdae:publishersName ?publisher }
+  OPTIONAL { ?edition rdae:placeOfPublication ?place }
+  OPTIONAL { ?edition rdae:editionStatement ?editionStatement }
+  OPTIONAL { ?edition dcterms:description ?extent }
+  OPTIONAL { ?edition bnf:isbn ?isbn }
+  OPTIONAL { ?edition rdae:note ?note }
+  OPTIONAL { ?edition rdfs:seeAlso ?catalogue }
+  OPTIONAL { ?edition rdarel:electronicReproduction ?reproduction }
+  OPTIONAL { ?edition bnf:OCR ?ocr }
+}`);
+}
+function digitisedForWorkQuery(id, limit) {
+  const work = iriOf(id);
+  const take = boundedInteger(limit, 1, 200, "limit") + 1;
+  return prefixed(`
+SELECT DISTINCT ?rank ?edition ?title ?reproduction ?ocr ?depiction WHERE {
+  {
+    ?edition rdarel:workManifested ${work} .
+    OPTIONAL { ?edition dcterms:title ?title }
+    { ?edition rdarel:electronicReproduction ?reproduction }
+    UNION
+    { ?edition bnf:OCR ?ocr }
+    BIND(0 AS ?rank)
+  }
+  UNION
+  {
+    ${work} foaf:depiction ?depiction .
+    BIND(${work} AS ?edition)
+    BIND(1 AS ?rank)
+  }
+}
+ORDER BY ?rank
+LIMIT ${take}`);
+}
+function digitisedForPersonQuery(id, limit) {
+  const person = iriOf(id);
+  const take = boundedInteger(limit, 1, 200, "limit") + 1;
+  return prefixed(`
+SELECT DISTINCT ?rank ?edition ?title ?reproduction ?ocr ?depiction WHERE {
+  {
+    ?work dcterms:creator ${person} .
+    ?edition rdarel:workManifested ?work .
+    OPTIONAL { ?edition dcterms:title ?title }
+    { ?edition rdarel:electronicReproduction ?reproduction }
+    UNION
+    { ?edition bnf:OCR ?ocr }
+    BIND(0 AS ?rank)
+  }
+  UNION
+  {
+    ${person} foaf:depiction ?depiction .
+    BIND(${person} AS ?edition)
+    BIND(1 AS ?rank)
+  }
+}
+ORDER BY ?rank
+LIMIT ${take}`);
+}
+function kindQuery(id) {
+  return prefixed(`
+SELECT DISTINCT ?type WHERE {
+  ${iriOf(id)} a ?type .
+}
+LIMIT 20`);
+}
+
+// src/bnf/parse.ts
+var P = {
+  type: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+  label: "http://www.w3.org/2000/01/rdf-schema#label",
+  seeAlso: "http://www.w3.org/2000/01/rdf-schema#seeAlso",
+  sameAs: "http://www.w3.org/2002/07/owl#sameAs",
+  exactMatch: "http://www.w3.org/2004/02/skos/core#exactMatch",
+  closeMatch: "http://www.w3.org/2004/02/skos/core#closeMatch",
+  prefLabel: "http://www.w3.org/2004/02/skos/core#prefLabel",
+  altLabel: "http://www.w3.org/2004/02/skos/core#altLabel",
+  created: "http://purl.org/dc/terms/created",
+  modified: "http://purl.org/dc/terms/modified",
+  title: "http://purl.org/dc/terms/title",
+  date: "http://purl.org/dc/terms/date",
+  creator: "http://purl.org/dc/terms/creator",
+  language: "http://purl.org/dc/terms/language",
+  subject: "http://purl.org/dc/terms/subject",
+  name: "http://xmlns.com/foaf/0.1/name",
+  givenName: "http://xmlns.com/foaf/0.1/givenName",
+  familyName: "http://xmlns.com/foaf/0.1/familyName",
+  depiction: "http://xmlns.com/foaf/0.1/depiction",
+  birth: "http://vocab.org/bio/0.1/birth",
+  death: "http://vocab.org/bio/0.1/death",
+  firstYear: "http://data.bnf.fr/ontology/bnf-onto/firstYear",
+  lastYear: "http://data.bnf.fr/ontology/bnf-onto/lastYear",
+  subjectLabel: "http://data.bnf.fr/ontology/bnf-onto/subject",
+  isni: "http://isni.org/ontology#identifierValid",
+  placeOfBirth: "http://rdvocab.info/ElementsGr2/placeOfBirth",
+  placeOfDeath: "http://rdvocab.info/ElementsGr2/placeOfDeath",
+  biographicalInformation: "http://rdvocab.info/ElementsGr2/biographicalInformation",
+  languageOfThePerson: "http://rdvocab.info/ElementsGr2/languageOfThePerson",
+  countryAssociated: "http://rdvocab.info/ElementsGr2/countryAssociatedWithThePerson",
+  fieldOfActivity: "http://rdvocab.info/ElementsGr2/fieldOfActivityOfThePerson",
+  formOfWork: "http://rdvocab.info/Elements/formOfWork",
+  statusOfIdentification: "http://rdvocab.info/Elements/statusOfIdentification",
+  /** The occupation, which RDA numbers rather than names. */
+  occupation: "http://rdaregistry.info/Elements/a/#P50113",
+  /** Expressions of a work, which are not editions. */
+  expressionOfWork: "http://rdaregistry.info/Elements/w/#P10078"
+};
+var ALIGNMENT_HOSTS = [
+  { host: "viaf.org", name: "viaf" },
+  { host: "idref.fr", name: "idref" },
+  { host: "dbpedia.org", name: "dbpedia" },
+  { host: "wikidata.org", name: "wikidata" },
+  { host: "isni.org", name: "isni" },
+  { host: "d-nb.info", name: "gnd" },
+  { host: "id.loc.gov", name: "loc" },
+  { host: "datos.bne.es", name: "bne" },
+  { host: "wikipedia.org", name: "wikipedia" },
+  { host: "musicbrainz.org", name: "musicbrainz" },
+  { host: "francearchives.gouv.fr", name: "francearchives" },
+  { host: "imslp.org", name: "imslp" },
+  { host: "catalogue.bnf.fr", name: "catalogue" }
+];
+var text = (term) => {
+  if (!term) return null;
+  const value = term.value.trim();
+  return value === "" ? null : value;
+};
+var integer = (term) => {
+  const raw = text(term);
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isInteger(value) ? value : null;
+};
+function idFromIri(iri) {
+  const ark = /ark:\/12148\/(c[bc][0-9a-z]+)/i.exec(iri);
+  if (ark?.[1]) return ark[1].toLowerCase();
+  const temp = /temp-work\/([0-9a-f]{32})/i.exec(iri);
+  if (temp?.[1]) return `temp-work/${temp[1].toLowerCase()}`;
+  return null;
+}
+var vocabularyTerm = (iri) => decodeURIComponent(iri.replace(/[/#]$/, "").split(/[/#]/).pop() ?? iri);
+function toDigitisedLink(address, role, fromId, fromTitle) {
+  if (!address || !isGallicaAddress(address)) return null;
+  const segment = /ark:\/12148\/([^/?#]+)/.exec(address)?.[1] ?? null;
+  if (!segment) return null;
+  const ark = segment.split(".")[0] ?? segment;
+  if (ark === "") return null;
+  return { ark, url: address, role, fromId, fromTitle };
+}
+function page(rows, limit, skipped) {
+  const more = rows.length > limit;
+  return skipped > 0 ? { rows: rows.slice(0, limit), hasMore: more, skipped } : { rows: rows.slice(0, limit), hasMore: more };
+}
+function byPredicate(results) {
+  const index = /* @__PURE__ */ new Map();
+  for (const row of results.results.bindings) {
+    const predicate = text(row.p);
+    if (predicate === null) continue;
+    const bucket = index.get(predicate);
+    if (bucket) bucket.push(row);
+    else index.set(predicate, [row]);
+  }
+  return index;
+}
+var firstValue = (index, predicate) => text(index.get(predicate)?.[0]?.o);
+var allValues = (index, predicate) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of index.get(predicate) ?? []) {
+    const value = text(row.o);
+    if (value !== null) seen.add(value);
+  }
+  return [...seen];
+};
+var allTerms = (index, predicate) => allValues(index, predicate).filter((value) => value.startsWith("http")).map(vocabularyTerm);
+var deweyClasses = (index, predicate) => allValues(index, predicate).filter((value) => value.includes("dewey.info/class/")).map(vocabularyTerm);
+var allWords = (index, predicate) => allValues(index, predicate).filter((value) => !value.startsWith("http"));
+function alignments(index, selfId) {
+  const found = {};
+  for (const predicate of [P.sameAs, P.exactMatch, P.closeMatch, P.seeAlso]) {
+    for (const address of allValues(index, predicate)) {
+      if (!address.startsWith("http")) continue;
+      if (selfId && address.includes(selfId)) continue;
+      let host;
+      try {
+        host = new URL(address).hostname.toLowerCase();
+      } catch {
+        continue;
+      }
+      const known = ALIGNMENT_HOSTS.find(
+        (entry) => host === entry.host || host.endsWith(`.${entry.host}`)
+      );
+      if (!known) continue;
+      (found[known.name] ??= /* @__PURE__ */ new Set()).add(address);
+    }
+  }
+  return Object.fromEntries(Object.entries(found).map(([name, set]) => [name, [...set]]));
+}
+function isniAddresses(index) {
+  return allValues(index, P.isni).map(
+    (value) => `https://isni.org/isni/${value.replace(/\s/g, "")}`
+  );
+}
+function toAuthorSummaries(results, limit) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  let skipped = 0;
+  for (const row of results.results.bindings) {
+    const iri = text(row.person);
+    const id = iri === null ? null : idFromIri(iri);
+    if (iri === null || id === null) {
+      skipped += 1;
+      continue;
+    }
+    if (seen.has(id)) continue;
+    seen.add(id);
+    rows.push({
+      id,
+      name: text(row.name),
+      label: text(row.label),
+      birthYear: integer(row.birthYear),
+      deathYear: integer(row.deathYear),
+      role: text(row.role),
+      sourceUrl: publicPageFor(iri)
+    });
+  }
+  return page(rows, limit, skipped);
+}
+function toAuthorDetail(results, id, pageUrl) {
+  const index = byPredicate(results);
+  const types = allValues(index, P.type);
+  const otherNames = [];
+  const seenLabels = /* @__PURE__ */ new Set();
+  for (const row of index.get(P.altLabel) ?? []) {
+    const label = text(row.o);
+    if (label === null || seenLabels.has(label)) continue;
+    seenLabels.add(label);
+    otherNames.push({ label, language: text(row.lang) });
+  }
+  const sameAs = alignments(index, id);
+  const isni = isniAddresses(index);
+  if (isni.length > 0) sameAs.isni = [.../* @__PURE__ */ new Set([...sameAs.isni ?? [], ...isni])];
+  const catalogueUrl = allValues(index, P.seeAlso).find((address) => address.includes("catalogue.bnf.fr")) ?? null;
+  const depictions = [];
+  for (const address of allValues(index, P.depiction)) {
+    const link = toDigitisedLink(address, "depiction", id, null);
+    if (link) depictions.push(link);
+  }
+  return {
+    id,
+    name: firstValue(index, P.name),
+    label: firstValue(index, P.prefLabel),
+    givenName: firstValue(index, P.givenName),
+    familyName: firstValue(index, P.familyName),
+    otherNames,
+    birthDate: firstValue(index, P.birth),
+    deathDate: firstValue(index, P.death),
+    birthYear: integer(index.get(P.firstYear)?.[0]?.o),
+    deathYear: integer(index.get(P.lastYear)?.[0]?.o),
+    birthPlace: firstValue(index, P.placeOfBirth),
+    deathPlace: firstValue(index, P.placeOfDeath),
+    biographicalInformation: firstValue(index, P.biographicalInformation),
+    occupation: firstValue(index, P.occupation),
+    languages: allTerms(index, P.languageOfThePerson),
+    countries: allTerms(index, P.countryAssociated),
+    fields: allWords(index, P.fieldOfActivity),
+    deweyClasses: deweyClasses(index, P.fieldOfActivity),
+    sameAs,
+    catalogueUrl,
+    recordCreated: firstValue(index, P.created),
+    recordModified: firstValue(index, P.modified),
+    depictions,
+    types,
+    truncated: results.results.bindings.length >= MOST_TRIPLES,
+    sourceUrl: pageUrl
+  };
+}
+function readStatus(statement, iri) {
+  if (statement !== null) {
+    const said = statement.toLowerCase();
+    if (said.includes("provisional")) return "provisional";
+    if (said.includes("established")) return "established";
+  }
+  return iri.includes("/temp-work/") ? "provisional" : "established";
+}
+function toWorkSummaries(results, limit) {
+  const order = [];
+  const byId = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const row of results.results.bindings) {
+    const iri = text(row.work);
+    const id = iri === null ? null : idFromIri(iri);
+    if (iri === null || id === null) {
+      skipped += 1;
+      continue;
+    }
+    let work = byId.get(id);
+    if (!work) {
+      work = {
+        id,
+        title: text(row.title),
+        date: text(row.date),
+        creators: [],
+        status: readStatus(text(row.status), iri),
+        sourceUrl: publicPageFor(iri)
+      };
+      byId.set(id, work);
+      order.push(id);
+    }
+    const creatorIri = text(row.creator);
+    const creatorId = creatorIri ? idFromIri(creatorIri) : null;
+    if (creatorId && !work.creators.some((c) => c.id === creatorId)) {
+      work.creators.push({ id: creatorId, name: text(row.creatorName) });
+    }
+  }
+  return page(
+    order.map((id) => byId.get(id)),
+    limit,
+    skipped
+  );
+}
+function toWorkDetail(results, id, iri, pageUrl) {
+  const index = byPredicate(results);
+  const types = allValues(index, P.type);
+  const truncated = results.results.bindings.length >= MOST_TRIPLES;
+  const creators = [];
+  for (const row of index.get(P.creator) ?? []) {
+    const creatorIri = text(row.o);
+    const creatorId = creatorIri ? idFromIri(creatorIri) : null;
+    if (!creatorId || creators.some((c) => c.id === creatorId)) continue;
+    creators.push({ id: creatorId, name: text(row.name) });
+  }
+  const depictions = [];
+  for (const address of allValues(index, P.depiction)) {
+    const link = toDigitisedLink(address, "depiction", id, null);
+    if (link) depictions.push(link);
+  }
+  const statusStatement = firstValue(index, P.statusOfIdentification);
+  const catalogueUrl = allValues(index, P.seeAlso).find((address) => address.includes("catalogue.bnf.fr")) ?? null;
+  return {
+    id,
+    title: firstValue(index, P.title),
+    label: firstValue(index, P.label),
+    date: firstValue(index, P.date),
+    firstYear: integer(index.get(P.firstYear)?.[0]?.o),
+    creators,
+    languages: allTerms(index, P.language),
+    forms: allTerms(index, P.formOfWork),
+    subjects: allWords(index, P.subjectLabel),
+    deweyClasses: deweyClasses(index, P.subject),
+    status: readStatus(statusStatement, iri),
+    statusStatement,
+    // A cut record makes this the ceiling rather than the count, so it is
+    // withheld rather than published as a number the record does not support.
+    expressionCount: truncated ? null : allValues(index, P.expressionOfWork).length,
+    sameAs: alignments(index, id),
+    catalogueUrl,
+    depictions,
+    types,
+    truncated,
+    sourceUrl: pageUrl
+  };
+}
+function toEditions(results, limit) {
+  const order = [];
+  const byId = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const row of results.results.bindings) {
+    const iri = text(row.edition);
+    const id = iri === null ? null : idFromIri(iri);
+    if (iri === null || id === null) {
+      skipped += 1;
+      continue;
+    }
+    let edition = byId.get(id);
+    if (!edition) {
+      edition = {
+        id,
+        title: text(row.title),
+        date: text(row.date),
+        year: integer(row.year),
+        publisher: text(row.publisher),
+        place: text(row.place),
+        editionStatement: text(row.editionStatement),
+        extent: text(row.extent),
+        isbn: text(row.isbn),
+        note: text(row.note),
+        catalogueUrl: text(row.catalogue),
+        digitised: [],
+        sourceUrl: publicPageFor(iri)
+      };
+      byId.set(id, edition);
+      order.push(id);
+    }
+    for (const [column, role] of [
+      ["reproduction", "reproduction"],
+      ["ocr", "ocr"]
+    ]) {
+      const link = toDigitisedLink(text(row[column]), role, id, edition.title);
+      if (link && !edition.digitised.some((existing) => existing.url === link.url)) {
+        edition.digitised.push(link);
+      }
+    }
+  }
+  return page(
+    order.map((id) => byId.get(id)),
+    limit,
+    skipped
+  );
+}
+function toDigitisedLinks(results, limit) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rowCount = results.results.bindings.length;
+  for (const row of results.results.bindings) {
+    const fromIri = text(row.edition);
+    const fromId = fromIri ? idFromIri(fromIri) ?? fromIri : "";
+    const title = text(row.title);
+    for (const [column, role] of [
+      ["reproduction", "reproduction"],
+      ["ocr", "ocr"],
+      ["depiction", "depiction"]
+    ]) {
+      const link = toDigitisedLink(text(row[column]), role, fromId, title);
+      if (!link || seen.has(link.url)) continue;
+      seen.add(link.url);
+      links.push(link);
+    }
+  }
+  return { rows: links.slice(0, limit), hasMore: links.length > limit || rowCount > limit };
+}
+function toTypes(results) {
+  const types = /* @__PURE__ */ new Set();
+  for (const row of results.results.bindings) {
+    const iri = text(row.type);
+    if (iri !== null) types.add(iri);
+  }
+  return [...types];
+}
+
+// src/bnf/rateLimiter.ts
+var RateLimiter = class {
+  baseIntervalMs;
+  maxIntervalMs;
+  intervalMs;
+  lastStartedAt = 0;
+  queue = Promise.resolve();
+  calmStreak = 0;
+  constructor(options) {
+    this.baseIntervalMs = options.intervalMs;
+    this.maxIntervalMs = options.maxIntervalMs ?? options.intervalMs * 8;
+    this.intervalMs = options.intervalMs;
+  }
+  /** The spacing in force, which callers report rather than guess. */
+  get currentIntervalMs() {
+    return this.intervalMs;
+  }
+  /**
+   * Run `task` with nothing else in flight.
+   *
+   * This only serialises. Spacing is claimed per attempt through
+   * `beforeRequest`, because a task that retries makes several requests and
+   * each of them owes the service the same gap.
+   */
+  schedule(task) {
+    const result = this.queue.then(task, task);
+    this.queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  /** Wait until enough time has passed since the previous request began. */
+  async beforeRequest() {
+    const elapsed = Date.now() - this.lastStartedAt;
+    const wait = Math.min(this.intervalMs, this.intervalMs - elapsed);
+    if (wait > 0) await sleep(wait);
+    this.lastStartedAt = Date.now();
+  }
+  /** Called when the service asks for room: double the gap, up to the ceiling. */
+  pushBack() {
+    this.calmStreak = 0;
+    this.intervalMs = Math.min(this.maxIntervalMs, this.intervalMs * 2);
+  }
+  /**
+   * Called on a clean answer. Recovery takes several in a row, so one lucky
+   * response after a rough patch does not undo the caution that earned it.
+   */
+  succeeded() {
+    if (this.intervalMs === this.baseIntervalMs) return;
+    this.calmStreak += 1;
+    if (this.calmStreak < 3) return;
+    this.calmStreak = 0;
+    this.intervalMs = Math.max(this.baseIntervalMs, Math.round(this.intervalMs / 2));
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/bnf/client.ts
+var PERSON_CLASS = "http://xmlns.com/foaf/0.1/Person";
+var WORK_CLASSES = /* @__PURE__ */ new Set([
+  "http://rdvocab.info/uri/schema/FRBRentitiesRDA/Work",
+  "http://rdaregistry.info/Elements/c/#C10001"
+]);
+function withGuarantees(config) {
+  const defaults = loadConfig({});
+  const bounded = (value, fallback, min, max) => {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) return fallback;
+    return Math.min(max, Math.max(min, parsed));
+  };
+  const claimed = typeof config.userAgent === "string" ? config.userAgent.trim() : "";
+  const identifier = defaults.userAgent;
+  return {
+    ...config,
+    // A caller may say who they are. Appending rather than replacing means the
+    // BnF can always tell which software is calling, and reach someone.
+    userAgent: claimed === "" || claimed.includes(REPO_URL) ? identifier : `${claimed} ${identifier}`,
+    minIntervalMs: bounded(
+      config.minIntervalMs,
+      defaults.minIntervalMs,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: bounded(config.timeoutMs, defaults.timeoutMs, 1e3, 3e5),
+    maxRetries: bounded(config.maxRetries, defaults.maxRetries, 0, 8),
+    cacheTtlMs: bounded(config.cacheTtlMs, defaults.cacheTtlMs, 0, 864e5),
+    cacheMaxEntries: bounded(config.cacheMaxEntries, defaults.cacheMaxEntries, 1, 5e3)
+  };
+}
+var BnfClient = class {
+  config;
+  logger;
+  limiter;
+  cache;
+  /** Questions already on the wire, so an identical one waits instead of asking. */
+  inFlight = /* @__PURE__ */ new Map();
+  fetchImpl;
+  constructor(options = {}) {
+    const base = { ...loadConfig(), ...options.config };
+    this.config = withGuarantees(base);
+    this.logger = options.logger ?? createLogger(this.config.logLevel);
+    this.limiter = new RateLimiter({ intervalMs: this.config.minIntervalMs });
+    this.cache = new Cache(this.config.cacheTtlMs, this.config.cacheMaxEntries);
+    this.fetchImpl = options.fetchImpl;
+  }
+  /** The pacing in force, which widens when the endpoint pushes back. */
+  get intervalMs() {
+    return this.limiter.currentIntervalMs;
+  }
+  /** What the BnF sees this client call itself. */
+  get userAgent() {
+    return this.config.userAgent;
+  }
+  /** The deadline one query is given, which callers report rather than guess. */
+  get timeoutMs() {
+    return this.config.timeoutMs;
+  }
+  /** The one address this client sends anything to. */
+  get endpoint() {
+    return SPARQL_ENDPOINT;
+  }
+  /**
+   * `cacheKey` is stated rather than taken from the query, because two reads of
+   * one query can produce different values: a list cut to five rows is not the
+   * same value as the same list cut to twenty, and serving one for the other
+   * would answer a size the caller never asked for.
+   */
+  read(cacheKey, query, parse) {
+    const hit = this.cache.get(cacheKey);
+    if (hit !== void 0) {
+      this.logger.debug(`cache hit ${cacheKey}`);
+      return Promise.resolve({
+        data: hit.value,
+        cached: true,
+        retrievedAt: new Date(hit.retrievedAt).toISOString()
+      });
+    }
+    const flying = this.inFlight.get(cacheKey);
+    if (flying !== void 0) {
+      this.logger.debug(`joining a request already in flight for ${cacheKey}`);
+      return flying;
+    }
+    const flight = this.fetchAndParse(cacheKey, query, parse);
+    this.inFlight.set(cacheKey, flight);
+    return flight.finally(() => this.inFlight.delete(cacheKey));
+  }
+  async fetchAndParse(cacheKey, query, parse) {
+    const results = await this.limiter.schedule(
+      () => runQuery({
+        query,
+        userAgent: this.config.userAgent,
+        timeoutMs: this.config.timeoutMs,
+        maxRetries: this.config.maxRetries,
+        limiter: this.limiter,
+        logger: this.logger,
+        ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
+      })
+    );
+    const retrievedAt = Date.now();
+    const data = parse(results);
+    this.cache.set(cacheKey, data, retrievedAt);
+    return { data, cached: false, retrievedAt: new Date(retrievedAt).toISOString() };
+  }
+  /** Read an identifier a caller wrote, refusing anything this dataset cannot address. */
+  identify(input) {
+    return parseEntityId(input);
+  }
+  /** The words a search will actually look for, which a tool reports back. */
+  words(input) {
+    return toSearchWords(input);
+  }
+  searchAuthors(name, limit, offset) {
+    const words = toSearchWords(name);
+    const query = searchAuthorsQuery(words, limit, offset);
+    return this.read(
+      `authors:${words.join("+")}:${limit}:${offset}`,
+      query,
+      (results) => toAuthorSummaries(results, limit)
+    );
+  }
+  async getAuthor(id) {
+    const result = await this.read(
+      `author:${id.id}`,
+      authorQuery(id),
+      (results) => toAuthorDetail(results, id.id, id.pageUrl)
+    );
+    if (!result.data.types.includes(PERSON_CLASS)) {
+      await this.refuse(id, result.data.types, "a person", "get_work reads a work.");
+    }
+    return result;
+  }
+  /**
+   * Say what an address is, when it is not the kind of thing that was asked for.
+   *
+   * A record the catalogue does not describe at all and a record describing
+   * something else are two different answers, and only one of them means the
+   * caller should go looking elsewhere.
+   */
+  async refuse(id, types, wanted, hint) {
+    const known = types.length > 0 ? types : (await this.read(`types:${id.id}`, kindQuery(id), toTypes)).data;
+    if (known.length === 0) {
+      throw notFound(`data.bnf.fr describes nothing at "${id.id}".`, {
+        hint: "Find the identifier with search_authors or search_works rather than writing one.",
+        url: id.pageUrl
+      });
+    }
+    throw notFound(
+      `"${id.id}" is described by data.bnf.fr, and it is not ${wanted}: it is typed ${known.join(", ")}.`,
+      { hint, url: id.pageUrl }
+    );
+  }
+  searchWorks(title, limit, offset) {
+    const words = toSearchWords(title);
+    const query = searchWorksQuery(words, limit, offset);
+    return this.read(
+      `works:${words.join("+")}:${limit}:${offset}`,
+      query,
+      (results) => toWorkSummaries(results, limit)
+    );
+  }
+  async getWork(id) {
+    const result = await this.read(
+      `work:${id.id}`,
+      workQuery(id),
+      (results) => toWorkDetail(results, id.id, id.iri, id.pageUrl)
+    );
+    if (!result.data.types.some((type) => WORK_CLASSES.has(type))) {
+      await this.refuse(
+        id,
+        result.data.types,
+        "a work",
+        "get_author reads a person, and list_editions reads the editions of a work."
+      );
+    }
+    return result;
+  }
+  listEditions(id, limit, offset) {
+    const query = editionsQuery(id, limit, offset);
+    return this.read(
+      `editions:${id.id}:${limit}:${offset}`,
+      query,
+      (results) => toEditions(results, limit)
+    );
+  }
+  /** Digitised documents attached to a work and to its editions. */
+  digitisedForWork(id, limit) {
+    return this.read(
+      `digitised-work:${id.id}:${limit}`,
+      digitisedForWorkQuery(id, limit),
+      (results) => toDigitisedLinks(results, limit)
+    );
+  }
+  /** Digitised documents attached to a person and to the editions of their works. */
+  digitisedForPerson(id, limit) {
+    return this.read(
+      `digitised-person:${id.id}:${limit}`,
+      digitisedForPersonQuery(id, limit),
+      (results) => toDigitisedLinks(results, limit)
+    );
+  }
+  /** What an address is typed as, which tells a person from a work. */
+  types(id) {
+    return this.read(`types:${id.id}`, kindQuery(id), toTypes);
+  }
+};
+
+// src/tools/findDigitised.ts
+import { z as z3 } from "zod";
+
+// src/tools/arguments.ts
+import { z } from "zod";
+var INVALID_INPUT = "invalid_input";
+function strictInput(shape) {
+  const declared = Object.keys(shape);
+  return z.strictObject(shape, {
+    error: (issue) => issue.code === "unrecognized_keys" ? unknownArgumentMessage(issue.keys, declared) : void 0
+  });
+}
+function unknownArgumentMessage(keys, declared) {
+  const named = keys.map((key) => {
+    const near = nearestArgument(key, declared);
+    return near ? `'${key}' (did you mean '${near}'?)` : `'${key}'`;
+  }).join(", ");
+  return `[${INVALID_INPUT}] Unknown ${keys.length > 1 ? "arguments" : "argument"} ${named}. This tool takes: ${declared.join(", ")}.`;
+}
+function nearestArgument(key, declared) {
+  const flatten = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const flat = flatten(key);
+  if (flat.length === 0) return void 0;
+  const sameName = declared.find((name) => flatten(name) === flat);
+  if (sameName) return sameName;
+  const overlapping = declared.find((name) => {
+    const other = flatten(name);
+    const [shorter, longer] = other.length < flat.length ? [other, flat] : [flat, other];
+    return shorter.length >= 3 && (longer.startsWith(shorter) || longer.endsWith(shorter));
+  });
+  if (overlapping) return overlapping;
+  let closest;
+  let shortest = Number.POSITIVE_INFINITY;
+  for (const name of declared) {
+    const distance = editDistance(flat, flatten(name));
+    if (distance < shortest) {
+      shortest = distance;
+      closest = name;
+    }
+  }
+  return shortest <= Math.max(1, Math.floor(flat.length / 3)) ? closest : void 0;
+}
+function editDistance(left, right) {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let row = 1; row <= left.length; row += 1) {
+    const current = [row];
+    for (let column = 1; column <= right.length; column += 1) {
+      const substitution = previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1);
+      current[column] = Math.min(substitution, previous[column] + 1, current[column - 1] + 1);
+    }
+    previous = current;
+  }
+  return previous[right.length];
+}
+
+// src/tools/shared.ts
+import { z as z2 } from "zod";
+var MAX_TEXT_CHARS = 2400;
+var SOURCE_NAME = "data.bnf.fr (Biblioth\xE8que nationale de France)";
+function retrievalDay(retrievedAt) {
+  const day = retrievedAt.slice(0, 10);
+  return /^\d{4}-\d{2}-\d{2}$/.test(day) ? day : retrievedAt;
+}
+function attribution(retrievedAt, sourceUrl) {
+  const credit = `Source: ${SOURCE_NAME}, retrieved ${retrievalDay(retrievedAt)}`;
+  return sourceUrl ? `${credit} \u2014 ${sourceUrl}` : credit;
+}
+var retrievedAtSchema = z2.string().describe(
+  "When these metadata were read from data.bnf.fr, as an ISO 8601 instant. The BnF licence asks for this date to be stated wherever the metadata are shown, so repeat it alongside the source."
+);
+var digitisedLinkSchema = z2.object({
+  ark: z2.string().describe("The Gallica ARK identifying the document."),
+  url: z2.string().describe("Open this to see the document. This server does not read it."),
+  role: z2.enum(["reproduction", "ocr", "depiction"]).describe(
+    "'reproduction' is the edition itself digitised. 'ocr' is the text a machine read off it. 'depiction' is an image illustrating the record, which can be a portrait or a page mentioning the subject rather than the work."
+  ),
+  from_id: z2.string().describe("The record this link hangs off."),
+  from_title: z2.string().nullable()
+});
+function indentMarkerLines(body) {
+  return body.replace(/^(Note|Source|Hint)(\s*:)/gim, " $1$2");
+}
+function onOneLine(value) {
+  return value.replace(/[\r\n\u2028\u2029]+/g, " ").trim();
+}
+function ok(structured, body, options) {
+  const credit = attribution(options.retrievedAt, options.sourceUrl);
+  const noteLines = (options.notes ?? []).map((note) => `Note: ${onOneLine(note)}`);
+  while (noteLines.length > 0 && noteLines.join("\n").length > MAX_TEXT_CHARS / 2) noteLines.pop();
+  const trailer = [...noteLines, credit].join("\n");
+  const cut = "\n\n[shortened; the full result is in the structured output]";
+  const budget = MAX_TEXT_CHARS - `
+
+${trailer}`.length;
+  const safe = indentMarkerLines(body);
+  const text2 = safe.length <= budget ? `${safe}
+
+${trailer}` : `${truncate(safe, Math.max(0, budget - cut.length))}${cut}
+
+${trailer}`;
+  return { content: [{ type: "text", text: text2 }], structuredContent: structured };
+}
+function toToolError(error) {
+  const known = error instanceof BnfError ? error : new BnfError("network_error", error instanceof Error ? error.message : String(error));
+  const lines = [`[${known.code}] ${onOneLine(known.message)}`];
+  if (known.details.hint) lines.push(`Hint: ${onOneLine(known.details.hint)}`);
+  return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
+}
+function truncate(text2, maxChars) {
+  if (text2.length <= maxChars) return text2;
+  return `${text2.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+}
+var NO_RANKING = "The full-text index answers whether a record matches, and it does not score how well. These rows are in the order the index returned them, so the row a person would call the obvious answer can sit anywhere in the list, or on a later page.";
+var GALLICA_CAVEAT = "These are links for a person to open. This server reads the BnF catalogue and never requests gallica.bnf.fr, so it cannot say whether a document opens, what it contains, or on what terms it may be reused.";
+var PROVISIONAL_CAVEAT = "A provisional record is one the BnF created to hold a title it has catalogued and not yet established as a work of its own. Its identifier can change, and it can be merged into an established record.";
+
+// src/tools/findDigitised.ts
+var PERSON_TYPE = "http://xmlns.com/foaf/0.1/Person";
+var WORK_TYPES = [
+  "http://rdvocab.info/uri/schema/FRBRentitiesRDA/Work",
+  "http://rdaregistry.info/Elements/c/#C10001"
+];
+var findDigitisedDescription = [
+  "Gather the digitised documents the Biblioth\xE8que nationale de France catalogue attaches to one person or one work, and return them as links.",
+  "Give the identifier of either; the tool reads what kind of record it is and follows the right path. For a work it walks the editions; for a person it takes the images on the record and the digitised editions of the works they are credited with.",
+  "Every result is a link for someone to open. This server reads the BnF catalogue and never requests gallica.bnf.fr, so it reports nothing about what is at the other end: not whether the document opens, not what it contains, not on what terms it may be reused.",
+  "It returns links and nothing else: no publisher, no date, no ISBN. Use list_editions when which edition a copy belongs to matters.",
+  "A 'depiction' illustrates a record and can be a page that merely mentions the subject. A 'reproduction' is an edition digitised. An 'ocr' link names a machine-read text of a document, which this server does not fetch."
+].join(" ");
+var findDigitisedInput = strictInput({
+  id: z3.string().min(1).max(200).describe(
+    "A person or work identifier, such as 'cb119219976' or 'cb11970626n'. The argument is named 'id' rather than 'work_id' or 'author_id' because it takes either."
+  ),
+  kind: z3.enum(["auto", "person", "work"]).default("auto").describe(
+    "Which kind of record the identifier names. 'auto' asks the catalogue, which costs one extra query."
+  ),
+  limit: z3.number().int().min(1).max(200).default(40)
+});
+var findDigitisedOutput = z3.object({
+  id: z3.string(),
+  kind: z3.enum(["person", "work"]).describe("What the catalogue types this record as."),
+  links: z3.array(digitisedLinkSchema),
+  counts: z3.object({
+    reproduction: z3.number().int(),
+    ocr: z3.number().int(),
+    depiction: z3.number().int()
+  }).describe("Links returned on this page, by role. These count links, not documents."),
+  has_more: z3.boolean(),
+  retrieved_at: retrievedAtSchema,
+  notes: z3.array(z3.string())
+});
+async function runFindDigitised(client, args) {
+  try {
+    const id = client.identify(args.id);
+    let kind;
+    const notes = [];
+    if (args.kind === "auto") {
+      if (id.kind === "temp-work") {
+        kind = "work";
+      } else {
+        const types = await client.types(id);
+        if (types.data.length === 0) {
+          return toToolError(
+            notFound(`data.bnf.fr describes nothing at "${id.id}".`, {
+              hint: "Find the identifier with search_authors or search_works rather than writing one.",
+              url: id.pageUrl
+            })
+          );
+        }
+        if (types.data.includes(PERSON_TYPE)) kind = "person";
+        else if (types.data.some((type) => WORK_TYPES.includes(type))) kind = "work";
+        else {
+          return toToolError(
+            notFound(
+              `"${id.id}" is described by data.bnf.fr, and it is neither a person nor a work: it is typed ${types.data.join(", ")}.`,
+              {
+                hint: "This tool follows a person or a work. For one edition, list_editions carries the digitised copies alongside the imprint.",
+                url: id.pageUrl
+              }
+            )
+          );
+        }
+      }
+    } else {
+      kind = args.kind;
+    }
+    const { data, cached, retrievedAt } = kind === "person" ? await client.digitisedForPerson(id, args.limit) : await client.digitisedForWork(id, args.limit);
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    const links = data.rows.map((link) => ({
+      ark: link.ark,
+      url: link.url,
+      role: link.role,
+      from_id: link.fromId,
+      from_title: link.fromTitle
+    }));
+    const counts = {
+      reproduction: countRole(data.rows, "reproduction"),
+      ocr: countRole(data.rows, "ocr"),
+      depiction: countRole(data.rows, "depiction")
+    };
+    if (links.length > 0) notes.push(GALLICA_CAVEAT);
+    if (counts.depiction > 0) {
+      notes.push(
+        `${counts.depiction === 1 ? "One of these is an image" : `${counts.depiction} of these are images`} the catalogue uses to illustrate the record. Such an image can be a portrait, a title page, or a newspaper page that mentions the subject in passing, and the catalogue does not say which.`
+      );
+    }
+    if (counts.ocr > 0) {
+      notes.push(
+        `${counts.ocr === 1 ? "One of these points" : `${counts.ocr} of these point`} at a text a machine read off a scanned document. This server names that text and does not read it.`
+      );
+    }
+    if (data.hasMore) {
+      notes.push(
+        args.limit >= 200 ? "The catalogue points at more documents than this tool will return in one answer, and it does not page: 200 is the ceiling. Read the editions with list_editions to reach the rest, one page at a time." : `More links exist than were returned. Raise 'limit' to see more of them, up to 200. This tool does not page, so a higher limit re-reads the links already shown rather than continuing after them.`
+      );
+    }
+    if (links.length === 0) {
+      notes.push(
+        `The catalogue attaches no digitised document to "${id.id}". That is a statement about the catalogue: the BnF digitises a fraction of what it holds, and a document can be on Gallica without the record here pointing at it.`
+      );
+    }
+    const body = links.length === 0 ? `The BnF catalogue attaches no digitised document to "${id.id}".` : `${links.length} link(s) for "${id.id}" (${kind}):
+${links.map((link, index) => {
+      const from = link.from_title ? ` \xB7 from: ${link.from_title}` : "";
+      return `${index + 1}. [${link.role}] ${link.url}${from}`;
+    }).join("\n")}`;
+    return ok(
+      {
+        id: id.id,
+        kind,
+        links,
+        counts,
+        has_more: data.hasMore,
+        retrieved_at: retrievedAt,
+        notes
+      },
+      body,
+      { retrievedAt, notes, sourceUrl: id.pageUrl }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+var countRole = (links, role) => links.filter((link) => link.role === role).length;
+
+// src/tools/getAuthor.ts
+import { z as z4 } from "zod";
+var getAuthorDescription = [
+  "Read one person's record in the Biblioth\xE8que nationale de France authority file, by the identifier search_authors returns.",
+  "It carries the dates and places of birth and death, the occupation the record names, the language and country it associates with the person, the field of activity with its Dewey class, and the addresses for the same person in VIAF, IdRef, DBpedia, Wikidata and ISNI.",
+  "It carries no biography. The field the BnF calls biographical information is a job title on most records and a single word on many, so quote it as what the catalogue states and do not build a life story out of it.",
+  "It does not list the person's works. The catalogue links them, and no tool here walks that link: search_works reads titles, so a work is found by its title rather than by its author.",
+  "'depictions' are images data.bnf.fr attaches to the person. They are links for a person to open; this server does not read them, and an image can be a page that mentions the person rather than a portrait of them."
+].join(" ");
+var getAuthorInput = strictInput({
+  author_id: z4.string().min(1).max(200).describe(
+    "The identifier from search_authors, such as 'cb119219976'. A full data.bnf.fr address is accepted too."
+  ),
+  include_depictions: z4.boolean().default(false).describe(
+    "Include the images data.bnf.fr attaches to the person. A well-known person can carry dozens, so they are left out by default. find_digitised gathers them with everything else."
+  )
+});
+var getAuthorOutput = z4.object({
+  author: z4.object({
+    id: z4.string(),
+    name: z4.string().nullable(),
+    label: z4.string().nullable().describe("The authority heading, usually with the dates."),
+    given_name: z4.string().nullable(),
+    family_name: z4.string().nullable(),
+    other_names: z4.array(z4.object({ label: z4.string(), language: z4.string().nullable() })).describe("Other headings the record carries, including transliterations and pen names."),
+    birth_date: z4.string().nullable().describe("As published, usually YYYY-MM-DD."),
+    death_date: z4.string().nullable(),
+    birth_year: z4.number().int().nullable(),
+    death_year: z4.number().int().nullable(),
+    birth_place: z4.string().nullable(),
+    death_place: z4.string().nullable(),
+    biographical_information: z4.string().nullable().describe(
+      "What the record states about the person. This is a job title on most records and a single word on many; it is not a biography."
+    ),
+    occupation: z4.string().nullable(),
+    languages: z4.array(z4.string()).describe("ISO 639-2 codes, such as 'fre'."),
+    countries: z4.array(z4.string()).describe("Country codes, such as 'fr'."),
+    fields: z4.array(z4.string()).describe("Fields of activity in the words of the record."),
+    dewey_classes: z4.array(z4.string()).describe("Dewey classes the fields point at, such as '800' for literature."),
+    same_as: z4.record(z4.string(), z4.array(z4.string())).describe("Addresses for the same person in other files, grouped by file."),
+    catalogue_url: z4.string().nullable().describe("The record in the BnF general catalogue."),
+    record_created: z4.string().nullable().describe("When the authority record was created."),
+    record_modified: z4.string().nullable().describe("When it was last changed."),
+    source_url: z4.string()
+  }),
+  depictions: z4.array(digitisedLinkSchema).optional(),
+  depiction_count: z4.number().int().describe(
+    "Images on Gallica that the record points at, counted whether or not they were returned. An illustration the record holds elsewhere is not counted, because this server describes Gallica documents and knows nothing about the others."
+  ),
+  retrieved_at: retrievedAtSchema,
+  notes: z4.array(z4.string())
+});
+async function runGetAuthor(client, args) {
+  try {
+    const id = client.identify(args.author_id);
+    const { data, cached, retrievedAt } = await client.getAuthor(id);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    if (data.biographicalInformation !== null) {
+      notes.push(
+        `The BnF states "${data.biographicalInformation}" as this person's biographical information. That field holds an occupation rather than a life, and this is all the catalogue says.`
+      );
+    }
+    if (data.deathDate === null && data.deathYear === null) {
+      notes.push(
+        "The record states no date of death. That can mean the person is living, or that the BnF has not recorded one; the catalogue does not distinguish the two."
+      );
+    }
+    if (Object.keys(data.sameAs).length > 0) {
+      notes.push(
+        "The addresses under 'same_as' are the BnF's own alignments to other files. Following one is how to reach a biography, which this catalogue does not hold."
+      );
+    }
+    if (data.depictions.length > 0) notes.push(GALLICA_CAVEAT);
+    const structured = {
+      author: {
+        id: data.id,
+        name: data.name,
+        label: data.label,
+        given_name: data.givenName,
+        family_name: data.familyName,
+        other_names: data.otherNames,
+        birth_date: data.birthDate,
+        death_date: data.deathDate,
+        birth_year: data.birthYear,
+        death_year: data.deathYear,
+        birth_place: data.birthPlace,
+        death_place: data.deathPlace,
+        biographical_information: data.biographicalInformation,
+        occupation: data.occupation,
+        languages: data.languages,
+        countries: data.countries,
+        fields: data.fields,
+        dewey_classes: data.deweyClasses,
+        same_as: data.sameAs,
+        catalogue_url: data.catalogueUrl,
+        record_created: data.recordCreated,
+        record_modified: data.recordModified,
+        source_url: data.sourceUrl
+      },
+      depiction_count: data.depictions.length,
+      retrieved_at: retrievedAt,
+      notes
+    };
+    if (args.include_depictions) {
+      structured.depictions = data.depictions.map((link) => ({
+        ark: link.ark,
+        url: link.url,
+        role: link.role,
+        from_id: link.fromId,
+        from_title: link.fromTitle
+      }));
+    }
+    const born = [
+      data.birthDate ?? (data.birthYear !== null ? String(data.birthYear) : null),
+      data.birthPlace
+    ].filter(Boolean).join(", ");
+    const died = [
+      data.deathDate ?? (data.deathYear !== null ? String(data.deathYear) : null),
+      data.deathPlace
+    ].filter(Boolean).join(", ");
+    const lines = [
+      data.label ?? data.name ?? data.id,
+      born ? `Born: ${born}` : "",
+      died ? `Died: ${died}` : "",
+      data.occupation ? `Occupation as recorded: ${data.occupation}` : "",
+      data.fields.length > 0 ? `Field of activity: ${data.fields.join(", ")}${data.deweyClasses.length > 0 ? ` (Dewey ${data.deweyClasses.join(", ")})` : ""}` : "",
+      data.languages.length > 0 ? `Language: ${data.languages.join(", ")}` : "",
+      data.countries.length > 0 ? `Country: ${data.countries.join(", ")}` : "",
+      data.otherNames.length > 0 ? `Also recorded as: ${data.otherNames.map((other) => other.label).join("; ")}` : "",
+      Object.keys(data.sameAs).length > 0 ? `Same person in: ${Object.entries(data.sameAs).map(([file, addresses]) => `${file} ${addresses[0]}`).join(" \xB7 ")}` : "",
+      data.catalogueUrl ? `BnF catalogue: ${data.catalogueUrl}` : "",
+      data.depictions.length > 0 ? `Images attached to this record: ${data.depictions.length}${args.include_depictions ? "" : " (ask with include_depictions, or use find_digitised)"}` : ""
+    ].filter(Boolean);
+    return ok(structured, lines.join("\n"), { retrievedAt, notes, sourceUrl: data.sourceUrl });
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/getWork.ts
+import { z as z5 } from "zod";
+var getWorkDescription = [
+  "Read one work's record in the Biblioth\xE8que nationale de France catalogue, by the identifier search_works returns.",
+  "It carries the title, everyone the record credits, the date the BnF gives the work, its language, its form and its subject with the Dewey class.",
+  "'status' says whether the record is established or provisional, and 'status_statement' repeats what the catalogue itself states. A provisional identifier can change, so cite an established one where there is a choice.",
+  "'expression_count' counts the expressions the record links, which is not a count of published editions: use list_editions for those."
+].join(" ");
+var getWorkInput = strictInput({
+  work_id: z5.string().min(1).max(200).describe(
+    "The identifier from search_works, such as 'cb11970626n' or 'temp-work/22d7f68c1a4bdd081ad7ca791fd3b730'."
+  ),
+  include_depictions: z5.boolean().default(false).describe(
+    "Include the images data.bnf.fr attaches to the work. A well-known work can carry dozens, so they are left out by default. find_digitised gathers them alongside the digitised editions."
+  )
+});
+var getWorkOutput = z5.object({
+  work: z5.object({
+    id: z5.string(),
+    title: z5.string().nullable(),
+    label: z5.string().nullable(),
+    date: z5.string().nullable().describe("The date the record gives the work, as published."),
+    first_year: z5.number().int().nullable(),
+    creators: z5.array(z5.object({ id: z5.string(), name: z5.string().nullable() })),
+    languages: z5.array(z5.string()).describe("ISO 639-2 codes."),
+    forms: z5.array(z5.string()).describe("Forms from the BnF work-form vocabulary, such as 'poesi' for poetry."),
+    subjects: z5.array(z5.string()).describe("Subjects in the words of the record."),
+    dewey_classes: z5.array(z5.string()),
+    status: z5.enum(["established", "provisional"]),
+    status_statement: z5.string().nullable().describe("What the record itself states, such as 'fully established' or 'provisional'."),
+    expression_count: z5.number().int().nullable().describe(
+      "Expressions the record links: translations, adaptations, recordings. This is not a count of published editions. Null when the record was longer than one query reads, since the number would then be the ceiling rather than the count."
+    ),
+    same_as: z5.record(z5.string(), z5.array(z5.string())),
+    catalogue_url: z5.string().nullable(),
+    source_url: z5.string()
+  }),
+  depictions: z5.array(digitisedLinkSchema).optional(),
+  depiction_count: z5.number().int().describe(
+    "Images on Gallica that the record points at, counted whether or not they were returned."
+  ),
+  retrieved_at: retrievedAtSchema,
+  notes: z5.array(z5.string())
+});
+async function runGetWork(client, args) {
+  try {
+    const id = client.identify(args.work_id);
+    const { data, cached, retrievedAt } = await client.getWork(id);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    if (data.status === "provisional") {
+      notes.push(
+        `This is a provisional record, addressed under 'temp-work' rather than by an ARK${data.statusStatement ? ` and stated as "${data.statusStatement}"` : ""}. ${PROVISIONAL_CAVEAT}`
+      );
+    } else {
+      notes.push(
+        `This is an established work record, addressed by the ARK '${data.id}'${data.statusStatement ? ` and stated as "${data.statusStatement}"` : ""}. That identifier is the one to cite.`
+      );
+    }
+    if (data.truncated) {
+      notes.push(
+        "This record is longer than one query reads, so parts of it are missing from this answer. A field shown as empty here may be filled on the record itself: open source_url before concluding that the BnF states nothing."
+      );
+    }
+    if (data.expressionCount !== null && data.expressionCount > 0) {
+      notes.push(
+        `The record links ${data.expressionCount} expression(s): translations, adaptations and recordings of this work. Published editions are a separate count, and list_editions is what reads them.`
+      );
+    }
+    if (data.creators.length === 0) {
+      notes.push(
+        "The record credits nobody with this work. That is normal for anonymous and traditional works, and it also happens on records a cataloguer has not finished."
+      );
+    }
+    if (data.depictions.length > 0) notes.push(GALLICA_CAVEAT);
+    const structured = {
+      work: {
+        id: data.id,
+        title: data.title,
+        label: data.label,
+        date: data.date,
+        first_year: data.firstYear,
+        creators: data.creators,
+        languages: data.languages,
+        forms: data.forms,
+        subjects: data.subjects,
+        dewey_classes: data.deweyClasses,
+        status: data.status,
+        status_statement: data.statusStatement,
+        expression_count: data.expressionCount,
+        same_as: data.sameAs,
+        catalogue_url: data.catalogueUrl,
+        source_url: data.sourceUrl
+      },
+      depiction_count: data.depictions.length,
+      retrieved_at: retrievedAt,
+      notes
+    };
+    if (args.include_depictions) {
+      structured.depictions = data.depictions.map((link) => ({
+        ark: link.ark,
+        url: link.url,
+        role: link.role,
+        from_id: link.fromId,
+        from_title: link.fromTitle
+      }));
+    }
+    const lines = [
+      [data.title ?? data.label ?? data.id, data.date ? `(${data.date})` : ""].filter(Boolean).join(" "),
+      data.creators.length > 0 ? `By: ${data.creators.map((creator) => creator.name ?? creator.id).join(", ")}` : "",
+      `Record: ${data.status === "provisional" ? "provisional" : "established"}`,
+      data.languages.length > 0 ? `Language: ${data.languages.join(", ")}` : "",
+      data.forms.length > 0 ? `Form: ${data.forms.join(", ")}` : "",
+      data.subjects.length > 0 ? `Subject: ${data.subjects.join(", ")}${data.deweyClasses.length > 0 ? ` (Dewey ${data.deweyClasses.join(", ")})` : ""}` : "",
+      data.catalogueUrl ? `BnF catalogue: ${data.catalogueUrl}` : ""
+    ].filter(Boolean);
+    return ok(structured, lines.join("\n"), { retrievedAt, notes, sourceUrl: data.sourceUrl });
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/listEditions.ts
+import { z as z6 } from "zod";
+var listEditionsDescription = [
+  "List the published editions of one work in the Biblioth\xE8que nationale de France catalogue, by the identifier search_works or get_work returns.",
+  "Each row carries the publisher, the place, the year, the edition statement, the extent in the words of the record, the ISBN when there is one, and the record in the BnF general catalogue.",
+  "An edition that has been digitised carries a link under 'digitised'. That link says a copy exists at that address; this server never opens it, so it cannot say whether the document is readable, complete, or free to reuse.",
+  "Rows are in the order the catalogue holds them, which is neither by date nor by importance."
+].join(" ");
+var listEditionsInput = strictInput({
+  work_id: z6.string().min(1).max(200).describe("The work identifier, such as 'cb11970626n'."),
+  limit: z6.number().int().min(1).max(50).default(10),
+  page: z6.number().int().min(1).max(100).default(1)
+});
+var editionRowSchema = z6.object({
+  id: z6.string().describe("The edition's own identifier in the BnF catalogue."),
+  title: z6.string().nullable().describe("The title as this edition carries it."),
+  date: z6.string().nullable().describe("The date as published, which can be a phrase such as '[s.d.]' for an undated one."),
+  year: z6.number().int().nullable().describe("The year, when the record states one as a number."),
+  publisher: z6.string().nullable(),
+  place: z6.string().nullable(),
+  edition_statement: z6.string().nullable().describe("Such as a numbered or revised edition."),
+  extent: z6.string().nullable().describe("The extent in the words of the record: pages, volumes, discs."),
+  isbn: z6.string().nullable(),
+  note: z6.string().nullable().describe("What the cataloguer wrote, as published."),
+  catalogue_url: z6.string().nullable(),
+  digitised: z6.array(digitisedLinkSchema).describe(
+    "Digitised copies of this edition, as links. An empty list means the catalogue records none here, not that none exists."
+  ),
+  source_url: z6.string()
+});
+var listEditionsOutput = z6.object({
+  work_id: z6.string(),
+  editions: z6.array(editionRowSchema),
+  page: z6.number().int(),
+  has_more: z6.boolean(),
+  digitised_count: z6.number().int().describe("Editions on this page carrying at least one link."),
+  retrieved_at: retrievedAtSchema,
+  notes: z6.array(z6.string())
+});
+async function runListEditions(client, args) {
+  try {
+    const id = client.identify(args.work_id);
+    const offset = (args.page - 1) * args.limit;
+    const { data, cached, retrievedAt } = await client.listEditions(id, args.limit, offset);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    const editions = data.rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      date: row.date,
+      year: row.year,
+      publisher: row.publisher,
+      place: row.place,
+      edition_statement: row.editionStatement,
+      extent: row.extent,
+      isbn: row.isbn,
+      note: row.note,
+      catalogue_url: row.catalogueUrl,
+      digitised: row.digitised.map((link) => ({
+        ark: link.ark,
+        url: link.url,
+        role: link.role,
+        from_id: link.fromId,
+        from_title: link.fromTitle
+      })),
+      source_url: row.sourceUrl
+    }));
+    const digitisedCount = editions.filter((edition) => edition.digitised.length > 0).length;
+    if (digitisedCount > 0) notes.push(GALLICA_CAVEAT);
+    if (data.hasMore) {
+      notes.push(`More editions exist beyond this page. Ask for page ${args.page + 1}.`);
+    }
+    if (editions.length === 0 && args.page > 1) {
+      notes.push(
+        `Page ${args.page} holds no row, which means the list ended earlier rather than that the work has no editions. Ask for page 1 to see it from the start.`
+      );
+    } else if (editions.length === 0) {
+      notes.push(
+        `The catalogue links no published edition to "${id.id}". A work record can exist with none: it happens on provisional records, and on works the BnF describes through an anthology rather than through an edition of their own. Check get_work to see what kind of record this is.`
+      );
+    }
+    if (editions.length > 0) {
+      notes.push(
+        "Rows are in the order the catalogue holds them. It is neither chronological nor an order of importance, so a first edition can appear anywhere in the list."
+      );
+    }
+    const body = editions.length === 0 ? args.page > 1 ? `Page ${args.page} of the editions of "${id.id}" holds no row.` : `The BnF catalogue links no edition to the work "${id.id}".` : `${editions.length} edition(s) of "${id.id}":
+${editions.map((edition, index) => {
+      const imprint = [edition.place, edition.publisher, edition.date].filter(Boolean).join(" : ");
+      const extra = [
+        edition.edition_statement,
+        edition.extent,
+        edition.isbn ? `ISBN ${edition.isbn}` : ""
+      ].filter(Boolean).join(" \xB7 ");
+      const links = edition.digitised.length > 0 ? `
+   digitised: ${edition.digitised.map((link) => `${link.role} ${link.url}`).join("  ")}` : "";
+      return `${index + 1}. ${edition.title ?? edition.id}${imprint ? ` \xB7 ${imprint}` : ""}${extra ? `
+   ${extra}` : ""}
+   ${edition.catalogue_url ?? edition.source_url}${links}`;
+    }).join("\n")}`;
+    return ok(
+      {
+        work_id: id.id,
+        editions,
+        page: args.page,
+        has_more: data.hasMore,
+        digitised_count: digitisedCount,
+        retrieved_at: retrievedAt,
+        notes
+      },
+      body,
+      { retrievedAt, notes }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/searchAuthors.ts
+import { z as z7 } from "zod";
+var searchAuthorsDescription = [
+  "Find a person in the Biblioth\xE8que nationale de France authority file by name, and get the identifier the other tools take.",
+  "This matches the name the BnF records, so it takes a surname, a full name or both names in either order. It does not read biographies, so it cannot find a person from what they wrote or what they did.",
+  "Several rows can carry one name: the BnF keeps more than one authority record for some people, and many people share a name. Read 'birth_year', 'death_year' and 'role' to tell them apart, and show the caller the choice rather than picking one.",
+  "Rows come back in the order the index returned them, which is not an order of relevance."
+].join(" ");
+var searchAuthorsInput = strictInput({
+  name: z7.string().min(1).max(200).describe("The person's name, such as 'Rimbaud' or 'Arthur Rimbaud'."),
+  limit: z7.number().int().min(1).max(50).default(10),
+  page: z7.number().int().min(1).max(100).default(1)
+});
+var authorRowSchema = z7.object({
+  id: z7.string().describe("Pass this to get_author, or to find_digitised."),
+  name: z7.string().nullable().describe("The name as data.bnf.fr writes it."),
+  label: z7.string().nullable().describe("The authority heading, which usually carries the dates in brackets."),
+  birth_year: z7.number().int().nullable(),
+  death_year: z7.number().int().nullable().describe("Null when the record states none."),
+  role: z7.string().nullable().describe(
+    "What the record says the person did. This field holds a job title far more often than a sentence, and is frequently a single word."
+  ),
+  source_url: z7.string().describe("The record's page. Show this when citing it.")
+});
+var searchAuthorsOutput = z7.object({
+  name: z7.string().describe("The name asked for."),
+  words_searched: z7.array(z7.string()).describe("The words the index was actually asked for, after punctuation was set aside."),
+  authors: z7.array(authorRowSchema),
+  page: z7.number().int(),
+  has_more: z7.boolean().describe("Whether the index held at least one further match beyond this page."),
+  retrieved_at: retrievedAtSchema,
+  notes: z7.array(z7.string())
+});
+function lifespan(birthYear, deathYear) {
+  if (birthYear !== null && deathYear !== null) return ` (${birthYear}\u2013${deathYear})`;
+  if (birthYear !== null) return ` (born ${birthYear})`;
+  if (deathYear !== null) return ` (died ${deathYear})`;
+  return "";
+}
+async function runSearchAuthors(client, args) {
+  try {
+    const words = client.words(args.name);
+    if (words.length === 0) {
+      return toToolError(
+        invalidInput(
+          `"${args.name}" holds no word to search for.`,
+          "Write the name in letters, such as 'Rimbaud'."
+        )
+      );
+    }
+    const offset = (args.page - 1) * args.limit;
+    if (offset + args.limit > TEXT_WINDOW) {
+      return toToolError(
+        invalidInput(
+          `Page ${args.page} at ${args.limit} rows a page reaches past row ${TEXT_WINDOW}, which is as far into the index as one search reads.`,
+          `Narrow the search instead. Rows past ${TEXT_WINDOW} are not a smaller part of the answer: they were never read, so an empty page there would say nothing about the catalogue.`
+        )
+      );
+    }
+    const { data, cached, retrievedAt } = await client.searchAuthors(args.name, args.limit, offset);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    const authors = data.rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      label: row.label,
+      birth_year: row.birthYear,
+      death_year: row.deathYear,
+      role: row.role,
+      source_url: row.sourceUrl
+    }));
+    if (authors.length > 0) notes.push(NO_RANKING);
+    const repeated = /* @__PURE__ */ new Map();
+    for (const author of authors) {
+      const key = (author.name ?? "").toLocaleLowerCase("fr");
+      if (key !== "") repeated.set(key, (repeated.get(key) ?? 0) + 1);
+    }
+    const shared = [...repeated.entries()].filter(([, count]) => count > 1);
+    if (shared.length > 0) {
+      notes.push(
+        `${shared.map(([name, count]) => `${count} records are named "${name}"`).join("; ")}. The BnF keeps more than one authority record for some people, and different people share names. Read the dates and the role before treating any of them as the person meant.`
+      );
+    }
+    if (data.hasMore) {
+      notes.push(
+        `More matches exist beyond this page. Ask for page ${args.page + 1}, or narrow the name. This server reports no total, because counting every match means asking the endpoint to walk the whole index a second time.`
+      );
+    }
+    if (authors.length === 0) {
+      notes.push(
+        `No record in the BnF authority file carries every one of these words in a name: ${words.map((word) => `"${word}"`).join(", ")}. A search here reads names, so a person known by a pen name is found under that name rather than their own.`
+      );
+    }
+    if (words.length < args.name.trim().split(/\s+/).length) {
+      notes.push(
+        `The index was asked for ${words.map((word) => `"${word}"`).join(", ")}; anything in the name that was not a word was set aside.`
+      );
+    }
+    const body = authors.length === 0 ? `No person in the BnF authority file matches "${args.name}".` : `${authors.length} record(s) for "${args.name}":
+${authors.map((author, index) => {
+      const life = lifespan(author.birth_year, author.death_year);
+      const role = author.role ? ` \xB7 ${author.role}` : "";
+      return `${index + 1}. ${author.name ?? author.label ?? author.id}${life}${role} \xB7 id: ${author.id}
+   ${author.source_url}`;
+    }).join("\n")}`;
+    return ok(
+      {
+        name: args.name,
+        words_searched: words,
+        authors,
+        page: args.page,
+        has_more: data.hasMore,
+        retrieved_at: retrievedAt,
+        notes
+      },
+      body,
+      { retrievedAt, notes }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/searchWorks.ts
+import { z as z8 } from "zod";
+var searchWorksDescription = [
+  "Find a work in the Biblioth\xE8que nationale de France catalogue by words in its title, and get the identifier get_work and list_editions take.",
+  "A row matches when its title carries every word given. The index returns no measure of how well a row matches, so the rows are in index order and the work a person would call the obvious answer can sit anywhere in the list or on a later page.",
+  "A study of a book carries the book's title, so a search for a famous title returns the criticism alongside the work. Read 'creators' to tell them apart.",
+  "This reads titles and nothing else. It cannot find the works of a named person: searching a person's name returns works written about them, whose creators are their critics.",
+  "'status' says whether the BnF has established the work as a record of its own or holds it provisionally under a title it has catalogued."
+].join(" ");
+var searchWorksInput = strictInput({
+  title: z8.string().min(1).max(200).describe("Words from the title, such as 'saison enfer'. Every word given has to appear."),
+  limit: z8.number().int().min(1).max(50).default(10),
+  page: z8.number().int().min(1).max(100).default(1)
+});
+var workRowSchema = z8.object({
+  id: z8.string().describe("Pass this to get_work, list_editions or find_digitised."),
+  title: z8.string().nullable(),
+  date: z8.string().nullable().describe("The year the record gives the work, as published."),
+  creators: z8.array(z8.object({ id: z8.string(), name: z8.string().nullable() })).describe("Everyone the record credits. Empty when the record credits nobody."),
+  status: z8.enum(["established", "provisional"]).describe(
+    "'established' is a work the BnF has settled as a record of its own. 'provisional' is a title it holds while a cataloguer settles it, whose identifier can change."
+  ),
+  source_url: z8.string()
+});
+var searchWorksOutput = z8.object({
+  title: z8.string().describe("The words asked for."),
+  words_searched: z8.array(z8.string()),
+  works: z8.array(workRowSchema),
+  page: z8.number().int(),
+  has_more: z8.boolean(),
+  retrieved_at: retrievedAtSchema,
+  notes: z8.array(z8.string())
+});
+async function runSearchWorks(client, args) {
+  try {
+    const words = client.words(args.title);
+    if (words.length === 0) {
+      return toToolError(
+        invalidInput(
+          `"${args.title}" holds no word to search for.`,
+          "Write the words of the title in letters, such as 'saison enfer'."
+        )
+      );
+    }
+    const offset = (args.page - 1) * args.limit;
+    if (offset + args.limit > TEXT_WINDOW) {
+      return toToolError(
+        invalidInput(
+          `Page ${args.page} at ${args.limit} rows a page reaches past row ${TEXT_WINDOW}, which is as far into the index as one search reads.`,
+          `Narrow the search instead. Rows past ${TEXT_WINDOW} are not a smaller part of the answer: they were never read, so an empty page there would say nothing about the catalogue.`
+        )
+      );
+    }
+    const { data, cached, retrievedAt } = await client.searchWorks(args.title, args.limit, offset);
+    const notes = [];
+    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    const works = data.rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      date: row.date,
+      creators: row.creators,
+      status: row.status,
+      source_url: row.sourceUrl
+    }));
+    if (works.length > 0) notes.push(NO_RANKING);
+    if (works.some((work) => work.status === "provisional")) notes.push(PROVISIONAL_CAVEAT);
+    if (words.length > 2) {
+      notes.push(
+        `All ${words.length} words were required: ${words.map((word) => `"${word}"`).join(", ")}. A record catalogued under a shorter form of the title carries fewer of them and falls out of the answer, so dropping a word widens the search.`
+      );
+    }
+    if (works.length > 0 && works.every((work) => work.status === "provisional")) {
+      notes.push(
+        "Every row on this page is a provisional record. The BnF creates one for a title it has catalogued without settling it as a work of its own, which is what a study of a famous book usually gets. An established record for the work itself can sit further down the index: ask for the next page, or search fewer words of the title."
+      );
+    }
+    if (data.hasMore) {
+      notes.push(
+        `More matches exist beyond this page. Ask for page ${args.page + 1}, or add a word to the title. This server reports no total: a count would read as a measure of the search, and this search has none.`
+      );
+    }
+    if (works.length === 0) {
+      notes.push(
+        `No work in the BnF catalogue has a title carrying every one of these words: ${words.map((word) => `"${word}"`).join(", ")}. Every word given has to appear, so dropping one widens the search.`
+      );
+    }
+    const body = works.length === 0 ? `No work in the BnF catalogue matches "${args.title}".` : `${works.length} work(s) whose title carries ${words.map((word) => `"${word}"`).join(" and ")}:
+${works.map((work, index) => {
+      const by = work.creators.length > 0 ? ` \xB7 ${work.creators.map((creator) => creator.name ?? creator.id).join(", ")}` : "";
+      const when = work.date ? ` (${work.date})` : "";
+      const status = work.status === "provisional" ? " \xB7 provisional record" : "";
+      return `${index + 1}. ${work.title ?? work.id}${when}${by}${status} \xB7 id: ${work.id}
+   ${work.source_url}`;
+    }).join("\n")}`;
+    return ok(
+      {
+        title: args.title,
+        words_searched: words,
+        works,
+        page: args.page,
+        has_more: data.hasMore,
+        retrieved_at: retrievedAt,
+        notes
+      },
+      body,
+      { retrievedAt, notes }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/server.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var INSTRUCTIONS = [
+  "Tools for data.bnf.fr, the open catalogue of the Biblioth\xE8que nationale de France. No API key and no account are needed.",
+  "The usual path is search_authors or search_works to get an identifier, then get_author, get_work or list_editions to read the record it names.",
+  "The BnF publishes these metadata on one condition: name the source and state the date they were retrieved. Every answer carries 'retrieved_at' for that reason, and repeating both alongside what you show is what the licence asks for.",
+  "Both searches read a full-text index that answers whether a title or a name matches and never scores how well, so rows come back in index order. Never present the first row as the best answer, and never describe a count as a ranking.",
+  "One person can hold several authority records, and search_authors returns all of them: show the caller the choice rather than picking one.",
+  "A work record is either established, with an ARK of its own, or provisional, addressed under 'temp-work' while a cataloguer settles it. A provisional identifier can change, so prefer an established one when citing.",
+  "The catalogue describes what the BnF holds; it does not hold the texts. A record can point at a digitised copy on Gallica, and those links are returned as addresses for a person to open. This server never requests gallica.bnf.fr, because the BnF places its metadata and its digitised contents under two different regimes, so it can say a document exists at a link and nothing about what is there.",
+  "This server paces itself, and a rate_limited error means the endpoint was asked to slow down, never that the thing you asked for is missing.",
+  "Every result carries a source_url. Credit data.bnf.fr and link what you use."
+].join(" ");
+function createServer(options = {}) {
+  const config = options.config ?? loadConfig();
+  const logger = options.logger ?? createLogger(config.logLevel);
+  const client = new BnfClient({
+    config,
+    logger,
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+  const server = new McpServer(
+    { name: "mcp-databnf", version: PKG_VERSION },
+    { instructions: INSTRUCTIONS }
+  );
+  server.registerTool(
+    "search_authors",
+    {
+      title: "Find a person in the BnF authority file",
+      description: searchAuthorsDescription,
+      inputSchema: searchAuthorsInput,
+      outputSchema: searchAuthorsOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runSearchAuthors(client, args)
+  );
+  server.registerTool(
+    "get_author",
+    {
+      title: "Read a person's record",
+      description: getAuthorDescription,
+      inputSchema: getAuthorInput,
+      outputSchema: getAuthorOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runGetAuthor(client, args)
+  );
+  server.registerTool(
+    "search_works",
+    {
+      title: "Find a work by its title",
+      description: searchWorksDescription,
+      inputSchema: searchWorksInput,
+      outputSchema: searchWorksOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runSearchWorks(client, args)
+  );
+  server.registerTool(
+    "get_work",
+    {
+      title: "Read a work's record",
+      description: getWorkDescription,
+      inputSchema: getWorkInput,
+      outputSchema: getWorkOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runGetWork(client, args)
+  );
+  server.registerTool(
+    "list_editions",
+    {
+      title: "List the editions of a work",
+      description: listEditionsDescription,
+      inputSchema: listEditionsInput,
+      outputSchema: listEditionsOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runListEditions(client, args)
+  );
+  server.registerTool(
+    "find_digitised",
+    {
+      title: "Gather the digitised documents attached to a record",
+      description: findDigitisedDescription,
+      inputSchema: findDigitisedInput,
+      outputSchema: findDigitisedOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runFindDigitised(client, args)
+  );
+  logger.info(
+    `ready: user-agent="${config.userAgent}", ${config.minIntervalMs}ms between requests, cache ${config.cacheTtlMs}ms`
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = async () => {
+    await server.close().catch(() => void 0);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[mcp-databnf] fatal: ${message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map