ai4l-library-dev 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,218 +1,191 @@
 #!/usr/bin/env node
 
+// src/env.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+function dotenvFile(env = process.env) {
+  const named = env.AI4L_LIBRARY_ENV?.trim();
+  if (named) return named;
+  if (existsSync(resolve(".env"))) return resolve(".env");
+  const lib = env.AI4L_LIBRARY_DIR?.trim() || (existsSync("/library") ? "/library" : "library");
+  return join(resolve(lib), ".env");
+}
+function loadDotenv(file = dotenvFile()) {
+  if (!existsSync(file)) return [];
+  const loaded = [];
+  for (const raw of readFileSync(file, "utf8").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const m = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let v = m[2].trim();
+    if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) v = v.slice(1, -1);
+    else v = v.replace(/\s+#.*$/, "");
+    if (process.env[m[1]] === void 0) {
+      process.env[m[1]] = v;
+      loaded.push(m[1]);
+    }
+  }
+  return loaded;
+}
+
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/tools.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
 import { z } from "zod";
 
 // src/entry.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { basename } from "path";
-function emptyStatus(requested, type, id, libraryDir) {
-  return {
-    requested,
-    type,
-    id,
-    entry: null,
-    entry_dir: null,
-    library_dir: libraryDir,
-    pmid: null,
-    pmcid: null,
-    doi: null,
-    title: null,
-    first_author: null,
-    year: null,
-    publication_types: [],
-    retracted: false,
-    level: null,
-    version: null,
-    retrieved_by: null,
-    retrieved_date: null,
-    attempts: [],
-    files: []
-  };
-}
-function renderAbstractMd(r) {
-  const line = [
-    r.authors.join(", ") || null,
-    r.journal,
-    r.year,
-    `PMID ${r.pmid}`,
-    r.doi ? `DOI ${r.doi}` : null,
-    r.pmcid ? `PMCID ${r.pmcid}` : null
-  ].filter(Boolean).join(" \xB7 ");
-  const body = r.abstract.length ? r.abstract.map((a) => a.label ? `**${a.label}.** ${a.text}` : a.text).join("\n\n") : "_No abstract available._";
-  return `# ${r.title}
-
-${line}
-
-## Abstract
+import { copyFileSync, existsSync as existsSync4, mkdirSync, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "fs";
+import { join as join4 } from "path";
+import { basename, dirname } from "path";
 
-${body}
-`;
-}
-function renderMeta(r, files, retrievedDate, converter) {
-  const lines = [
-    ["pmid", r.pmid],
-    ["pmcid", r.pmcid ?? ""],
-    ["doi", r.doi ?? ""],
-    ["title", JSON.stringify(r.title)],
-    ["first_author", r.firstAuthor ?? ""],
-    ["year", r.year ?? ""],
-    ["publication_types", r.publicationTypes.join(", ")],
-    ["retracted", r.publicationTypes.includes("Retracted Publication") ? "yes" : "no"],
-    ["level", "abstract"],
-    ["version", ""],
-    ["files", files.join(", ")],
-    ["retrieved_by", "pubmed"],
-    ["retrieved_date", retrievedDate],
-    ["converted_by", converter],
-    ["attempts", ""]
-  ];
-  return "---\n" + lines.map(([k, v]) => v === "" ? `${k}:` : `${k}: ${v}`).join("\n") + "\n---\n";
-}
-function entryExists(p) {
-  return existsSync(p.meta);
-}
-function writeEntry(p, r, xml, converter) {
-  mkdirSync(p.entryDir, { recursive: true });
-  const files = [basename(p.xml), basename(p.md)];
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  writeFileSync(p.xml, xml);
-  writeFileSync(p.md, renderAbstractMd(r));
-  writeFileSync(p.meta, renderMeta(r, files, today, converter));
-}
-function parseFrontmatter(md) {
-  const m = /^---\n([\s\S]*?)\n---/.exec(md);
-  const out = {};
-  for (const line of (m?.[1] ?? "").split("\n")) {
-    const i = line.indexOf(":");
-    if (i > 0) out[line.slice(0, i).trim()] = line.slice(i + 1).trim();
-  }
-  return out;
-}
-var list = (v) => v ? v.split(",").map((s) => s.trim()).filter(Boolean) : [];
-var opt = (v) => v ? v : null;
-function readStatus(p, base) {
-  const fm = parseFrontmatter(readFileSync(p.meta, "utf8"));
-  let title = opt(fm.title);
-  if (title?.startsWith('"')) {
-    try {
-      title = JSON.parse(title);
-    } catch {
-    }
-  }
-  return {
-    ...base,
-    entry: p.entry,
-    entry_dir: p.entryDir,
-    pmid: opt(fm.pmid),
-    pmcid: opt(fm.pmcid),
-    doi: opt(fm.doi),
-    title,
-    first_author: opt(fm.first_author),
-    year: opt(fm.year),
-    publication_types: list(fm.publication_types),
-    retracted: fm.retracted === "yes",
-    level: opt(fm.level) ?? null,
-    version: opt(fm.version),
-    retrieved_by: opt(fm.retrieved_by),
-    retrieved_date: opt(fm.retrieved_date),
-    attempts: list(fm.attempts),
-    files: list(fm.files)
-  };
-}
+// src/pubmed.ts
+import { XMLParser } from "fast-xml-parser";
 
-// src/ids.ts
-var SUPPORTED = /* @__PURE__ */ new Set(["pmid"]);
-var KNOWN = /* @__PURE__ */ new Set(["pmid", "pmc", "doi", "nct"]);
-function parseId(raw) {
-  const requested = String(raw ?? "").trim();
-  const bare = /^\d+$/.test(requested);
-  const m = bare ? null : /^([A-Za-z][A-Za-z0-9_-]*):(.+)$/.exec(requested);
-  if (!bare && !m) return { requested, type: null, id: null, error: "invalid id" };
-  const type = bare ? "pmid" : m[1].toLowerCase();
-  const value = bare ? requested : m[2].trim();
-  if (!KNOWN.has(type)) return { requested, type, id: value, error: "invalid id" };
-  if (!SUPPORTED.has(type)) return { requested, type, id: value, error: "type not supported yet" };
-  if (!/^[1-9]\d*$/.test(value)) return { requested, type, id: value, error: "invalid id" };
-  return { requested, type, id: value };
-}
+// src/contact.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
 
 // src/layout.ts
+import { createHash } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { join, resolve } from "path";
-var LIBRARY_DIR = (() => {
-  const env = process.env.LIBRARY_DIR;
-  if (env && env.trim()) return resolve(env.trim());
+import { join as join2, resolve as resolve2 } from "path";
+var AI4L_LIBRARY_DIR = (() => {
+  const env = process.env.AI4L_LIBRARY_DIR;
+  if (env && env.trim()) return resolve2(env.trim());
   if (existsSync2("/library")) return "/library";
-  return resolve("library");
+  return resolve2("library");
 })();
+var doiSlug = (doi) => doi.toLowerCase().replace(/[^a-z0-9.-]+/g, "_");
 function entryDirRel(type, num) {
+  if (type === "doi") {
+    const h = createHash("sha1").update(num).digest("hex");
+    return `${type}/${h.slice(0, 2)}/${h.slice(0, 4)}/${num}`;
+  }
+  if (!/^\d+$/.test(num)) return `${type}/${num.slice(0, 2)}/${num.slice(0, 4)}/${num}`;
   const l1 = num.length > 6 ? num.slice(0, -6) : "0";
   const l2 = num.length > 4 ? num.slice(0, -4) : "0";
   return `${type}/${l1}/${l2}/${num}`;
 }
 function entryPaths(libraryDir, type, num) {
+  if (type === "doi") num = doiSlug(num);
   const entry = `${type}-${num}`;
-  const entryDir = join(libraryDir, entryDirRel(type, num));
+  const entryDir = join2(libraryDir, entryDirRel(type, num));
   return {
     entry,
     entryDir,
-    xml: join(entryDir, `${entry}-abstract.xml`),
-    md: join(entryDir, `${entry}-abstract.md`),
-    meta: join(entryDir, `${entry}-meta.md`)
+    xml: join2(entryDir, `${entry}-abstract.xml`),
+    md: join2(entryDir, `${entry}-abstract.md`),
+    meta: join2(entryDir, `${entry}-meta.md`),
+    fulltextMd: join2(entryDir, `${entry}-fulltext.md`),
+    fulltextRaw: (format) => join2(entryDir, `${entry}-fulltext.${format}`)
   };
 }
 
+// src/contact.ts
+var DEFAULT = "hello@forever-healthy.org";
+function contactEmail() {
+  const file = process.env.AI4L_LIBRARY_CONFIG?.trim() || join3(AI4L_LIBRARY_DIR, "config.json");
+  let v = "";
+  if (existsSync3(file)) {
+    try {
+      v = String(JSON.parse(readFileSync2(file, "utf8")).contact_email ?? "");
+    } catch {
+    }
+  }
+  v = v.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => process.env[n] ?? "").trim();
+  return v || process.env.CONTACT_EMAIL?.trim() || DEFAULT;
+}
+
+// src/http.ts
+var TIMEOUT_MS = 3e4;
+var CHROME_UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36";
+var LIBRARY_UA = `ai4l-library (+https://github.com/forever-healthy/AI4L-library; ${contactEmail()})`;
+function httpReason(status, body) {
+  const m = body.length < 4e3 && /<statusCode>([A-Z_]+)<\/statusCode>|"statusCode"\s*:\s*"([A-Z_]+)"/.exec(body);
+  return m ? `HTTP ${status} ${m[1] ?? m[2]}` : `HTTP ${status}`;
+}
+var DOWNLOAD_HEADERS = { "User-Agent": CHROME_UA, "Accept": "application/pdf,text/html,application/xml;q=0.9,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.9" };
+async function fetchBytes(url, headers = DOWNLOAD_HEADERS) {
+  let last = "unknown error", finalUrl = "", lastBody = "", lastType = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(TIMEOUT_MS), redirect: "follow" });
+      if (res.ok) return { bytes: Buffer.from(await res.arrayBuffer()), contentType: res.headers.get("content-type") ?? "", url: res.url };
+      lastBody = (await res.text().catch(() => "")).slice(0, 4e3);
+      lastType = res.headers.get("content-type") ?? "";
+      last = res.status < 500 ? httpReason(res.status, lastBody) : `HTTP ${res.status}`;
+      finalUrl = res.url;
+      if (res.status !== 429 && res.status < 500) break;
+    } catch (e) {
+      last = e instanceof Error && e.name === "TimeoutError" ? "timeout" : e instanceof Error ? e.message : String(e);
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  throw Object.assign(new Error(last), finalUrl ? { url: finalUrl } : {}, lastBody ? { body: lastBody, contentType: lastType } : {});
+}
+async function fetchText(url, headers = {}) {
+  let last = "unknown error";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(TIMEOUT_MS), redirect: "follow" });
+      if (res.ok) return await res.text();
+      last = res.status < 500 ? httpReason(res.status, await res.text().catch(() => "")) : `HTTP ${res.status}`;
+      if (res.status !== 429 && res.status < 500) break;
+    } catch (e) {
+      last = e instanceof Error && e.name === "TimeoutError" ? "timeout" : e instanceof Error ? e.message : String(e);
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  throw new Error(last);
+}
+
 // src/pubmed.ts
-import { XMLParser } from "fast-xml-parser";
+var CORRECTION_TYPES = {
+  ErratumIn: "erratum_in",
+  RetractionIn: "retraction_in",
+  PartialRetractionIn: "partial_retraction_in",
+  RetractedandRepublishedIn: "retracted_and_republished_in",
+  ExpressionOfConcernIn: "expression_of_concern_in",
+  UpdateIn: "update_in"
+};
+var RETRACTION_TYPES = /* @__PURE__ */ new Set(["retraction_in", "partial_retraction_in", "retracted_and_republished_in"]);
+var isRetractionNotice = (c) => RETRACTION_TYPES.has(c.type);
 var EFETCH = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi";
-var TIMEOUT_MS = 3e4;
 function efetchUrl(pmid) {
   const u = new URL(EFETCH);
   u.searchParams.set("db", "pubmed");
   u.searchParams.set("id", pmid);
   u.searchParams.set("retmode", "xml");
   if (process.env.NCBI_API_KEY) u.searchParams.set("api_key", process.env.NCBI_API_KEY);
-  if (process.env.CONTACT_EMAIL) {
-    u.searchParams.set("tool", "ai4l-library");
-    u.searchParams.set("email", process.env.CONTACT_EMAIL);
-  }
+  u.searchParams.set("tool", "ai4l-library");
+  u.searchParams.set("email", contactEmail());
   return u.toString();
 }
 async function fetchPubmedXml(pmid) {
-  const url = efetchUrl(pmid);
-  let last;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const res = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
-      if (res.ok) return await res.text();
-      last = new Error(`HTTP ${res.status}`);
-      if (res.status !== 429 && res.status < 500) break;
-    } catch (e) {
-      last = e;
-    }
+  try {
+    return await fetchText(efetchUrl(pmid));
+  } catch (e) {
+    throw new Error(`pubmed fetch failed: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const msg = last instanceof Error ? last.message : String(last);
-  throw new Error(`pubmed fetch failed: ${msg}`);
 }
 var parser = new XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
   parseTagValue: false,
   processEntities: true,
-  stopNodes: ["*.ArticleTitle", "*.AbstractText"],
-  isArray: (name) => ["PubmedArticle", "AbstractText", "Author", "ArticleId", "PublicationType"].includes(name)
+  stopNodes: ["*.ArticleTitle", "*.AbstractText", "*.CoiStatement"],
+  isArray: (name) => ["PubmedArticle", "PubmedBookArticle", "AbstractText", "Author", "ArticleId", "PublicationType", "CommentsCorrections", "Grant", "AuthorList"].includes(name)
 });
 function text(n) {
   if (n == null) return "";
   if (typeof n === "object") return text(n["#text"]);
   return String(n);
 }
+var plain = (n) => decodeEntities(text(n)).trim();
 function inlineText(raw) {
   return decodeEntities(raw.replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
 }
@@ -222,7 +195,10 @@ function decodeEntities(s) {
 function parsePubmedXml(xml) {
   const doc = parser.parse(xml);
   const article = doc?.PubmedArticleSet?.PubmedArticle?.[0];
-  if (!article) return null;
+  if (!article) {
+    const book = doc?.PubmedArticleSet?.PubmedBookArticle?.[0];
+    return book ? parseBook(book) : null;
+  }
   const cit = article.MedlineCitation ?? {};
   const art = cit.Article ?? {};
   const ids = article.PubmedData?.ArticleIdList?.ArticleId ?? [];
@@ -230,15 +206,15 @@ function parsePubmedXml(xml) {
     const hit = ids.find((i) => i["@_IdType"] === t);
     return hit ? text(hit).trim() || null : null;
   };
-  const authorList = art.AuthorList?.Author ?? [];
+  const authorList = art.AuthorList?.[0]?.Author ?? [];
   const authors = authorList.map((a) => {
-    if (a.CollectiveName) return text(a.CollectiveName).trim();
-    const last = text(a.LastName).trim();
-    const ini = text(a.Initials).trim();
+    if (a.CollectiveName) return plain(a.CollectiveName);
+    const last = plain(a.LastName);
+    const ini = plain(a.Initials);
     return [last, ini].filter(Boolean).join(" ");
   }).filter(Boolean);
   const first = authorList[0];
-  const firstAuthor = first ? text(first.CollectiveName ?? first.LastName).trim() || null : null;
+  const firstAuthor = first ? plain(first.CollectiveName ?? first.LastName) || null : null;
   const pub = art.Journal?.JournalIssue?.PubDate ?? {};
   let year = text(pub.Year).trim() || null;
   if (!year) year = /\d{4}/.exec(text(pub.MedlineDate))?.[0] ?? null;
@@ -246,85 +222,3528 @@ function parsePubmedXml(xml) {
     label: typeof a === "object" ? a["@_Label"] ?? null : null,
     text: inlineText(text(a))
   })).filter((a) => a.text);
+  const corrections = (cit.CommentsCorrectionsList?.CommentsCorrections ?? []).flatMap((c) => {
+    const type = CORRECTION_TYPES[String(c["@_RefType"] ?? "")];
+    if (!type) return [];
+    return [{ type, pmid: text(c.PMID).trim() || null, source: inlineText(text(c.RefSource)) }];
+  });
+  const funding = [];
+  for (const g of art.GrantList?.Grant ?? []) {
+    const a = plain(g.Agency);
+    if (a && !funding.includes(a)) funding.push(a);
+  }
   return {
+    coi: inlineText(text(cit.CoiStatement)) || null,
+    funding,
     pmid: text(cit.PMID).trim() || idOf("pubmed") || "",
     pmcid: idOf("pmc"),
     doi: idOf("doi"),
     title: inlineText(text(art.ArticleTitle)),
     authors,
     firstAuthor,
-    journal: text(art.Journal?.Title).trim() || null,
+    journal: plain(art.Journal?.Title) || null,
     year,
-    publicationTypes: (art.PublicationTypeList?.PublicationType ?? []).map((p) => text(p).trim()).filter(Boolean),
-    abstract
+    publicationTypes: (art.PublicationTypeList?.PublicationType ?? []).map(plain).filter(Boolean),
+    abstract,
+    corrections
+  };
+}
+function parseBook(b) {
+  const d = b.BookDocument ?? {};
+  const book = d.Book ?? {};
+  const ids = [...d.ArticleIdList?.ArticleId ?? [], ...b.PubmedBookData?.ArticleIdList?.ArticleId ?? []];
+  const idOf = (t) => {
+    const hit = ids.find((i) => i["@_IdType"] === t);
+    return hit ? text(hit).trim() || null : null;
+  };
+  const lists = [...d.AuthorList ?? [], ...book.AuthorList ?? []];
+  const pick = lists.find((l) => (l["@_Type"] ?? "authors") === "authors" && (l.Author ?? []).length) ?? lists.find((l) => (l.Author ?? []).length);
+  const people = pick?.Author ?? [];
+  const authors = people.map((a) => a.CollectiveName ? plain(a.CollectiveName) : [plain(a.LastName), plain(a.Initials)].filter(Boolean).join(" ")).filter(Boolean);
+  const first = people[0];
+  const abstract = (d.Abstract?.AbstractText ?? []).map((a) => ({ label: typeof a === "object" ? a["@_Label"] ?? null : null, text: inlineText(text(a)) })).filter((a) => a.text);
+  const types = ["Book", ...(d.PublicationType ?? []).map(plain).filter(Boolean)];
+  return {
+    pmid: text(d.PMID).trim() || idOf("pubmed") || "",
+    pmcid: null,
+    doi: idOf("doi") ?? (text(book.ELocationID).trim() || null),
+    title: inlineText(text(d.ArticleTitle)) || inlineText(text(book.BookTitle)),
+    authors,
+    firstAuthor: first ? plain(first.CollectiveName ?? first.LastName) || null : null,
+    journal: plain(book.Publisher?.PublisherName) || null,
+    year: text(book.PubDate?.Year).trim() || null,
+    publicationTypes: [...new Set(types)],
+    abstract,
+    corrections: [],
+    coi: null,
+    funding: []
   };
 }
 
-// src/tools.ts
-var pkg = (() => {
+// src/spl.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+var DAILYMED_PAGE = (setid) => `https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=${setid}`;
+var SPL_URL = (setid) => `https://dailymed.nlm.nih.gov/dailymed/services/v2/spls/${setid}.xml`;
+async function fetchSpl(setid) {
+  const xml = await fetchText(SPL_URL(setid), { "User-Agent": LIBRARY_UA, Accept: "application/xml, */*;q=0.8" });
+  if (!/<document[\s>]/.test(xml.slice(0, 3e3))) throw new Error("dailymed: not an SPL document");
+  return xml;
+}
+var parser2 = new XMLParser2({ preserveOrder: true, ignoreAttributes: false, attributeNamePrefix: "@_", parseTagValue: false, trimValues: false, processEntities: true, htmlEntities: true });
+var tagOf = (n) => Object.keys(n).find((k) => k !== ":@") ?? "";
+var kids = (n) => n[tagOf(n)] ?? [];
+var attr = (n, a) => n[":@"]?.[`@_${a}`] ?? "";
+var squash = (s) => s.replace(/\s+/g, " ").trim();
+var child = (n, tag) => kids(n).find((x) => tagOf(x) === tag);
+function findDeep(nodes, tag) {
+  for (const n of nodes) {
+    if ("#text" in n) continue;
+    if (tagOf(n) === tag) return n;
+    const h = findDeep(kids(n), tag);
+    if (h) return h;
+  }
+  return void 0;
+}
+function inline(nodes) {
+  let out = "";
+  for (const n of nodes) {
+    if ("#text" in n) {
+      out += String(n["#text"]);
+      continue;
+    }
+    const t = tagOf(n);
+    const inner = () => inline(kids(n));
+    switch (t) {
+      case "content": {
+        const style = attr(n, "styleCode").toLowerCase();
+        const s = inner();
+        out += /bold/.test(style) ? `**${s}**` : /italic/.test(style) ? `*${s}*` : s;
+        break;
+      }
+      case "sup":
+        out += `^${inner()}^`;
+        break;
+      case "sub":
+        out += `~${inner()}~`;
+        break;
+      case "br":
+        out += " ";
+        break;
+      case "footnote":
+        out += ` (${squash(inner())})`;
+        break;
+      case "footnoteRef":
+      case "renderMultiMedia":
+        break;
+      default:
+        out += inner();
+    }
+  }
+  return out;
+}
+function table(n) {
+  const row2 = (x) => kids(x).filter((c) => ["td", "th"].includes(tagOf(c))).map((c) => squash(inline(kids(c))).replace(/\|/g, "\\|"));
+  const collect = (nodes, into) => {
+    for (const x of nodes) {
+      if ("#text" in x) continue;
+      if (tagOf(x) === "tr") into.push(row2(x));
+      else if (!["thead", "tfoot"].includes(tagOf(x))) collect(kids(x), into);
+    }
+  };
+  const head = [], body = [], foot = [];
+  for (const x of kids(n)) {
+    const t = tagOf(x);
+    if (t === "thead") collect(kids(x), head);
+    else if (t === "tfoot") collect(kids(x), foot);
+    else if (t === "tr") body.push(row2(x));
+    else if (!("#text" in x) && t !== "caption") collect(kids(x), body);
+  }
+  const rows = [...head, ...body];
+  if (!rows.length) return "";
+  const width = Math.max(...rows.map((r) => r.length));
+  const line = (r) => `| ${[...r, ...Array(width - r.length).fill("")].join(" | ")} |`;
+  const cap = child(n, "caption");
+  const title = cap ? squash(inline(kids(cap))) : "";
+  const notes = foot.map((r) => r.filter(Boolean).join(" ")).filter(Boolean);
+  return [title ? `**${title}**` : "", line(rows[0]), `| ${Array(width).fill("---").join(" | ")} |`, ...rows.slice(1).map(line), ...notes.length ? ["", ...notes] : []].filter((l, i) => l || i > 0).join("\n");
+}
+function blocks(nodes, depth) {
+  const out = [];
+  for (const n of nodes) {
+    if ("#text" in n) {
+      const t2 = squash(String(n["#text"]));
+      if (t2) out.push(t2);
+      continue;
+    }
+    const t = tagOf(n);
+    const c = kids(n);
+    switch (t) {
+      case "paragraph": {
+        const s = squash(inline(c.filter((x) => !["table", "list"].includes(tagOf(x)))));
+        if (s) out.push(s);
+        out.push(...blocks(c.filter((x) => ["table", "list"].includes(tagOf(x))), depth));
+        break;
+      }
+      case "list": {
+        const ordered = /^(ordered|numbered|arabic|roman|alpha)/i.test(attr(n, "listType"));
+        let i = 0;
+        for (const it of c.filter((x) => tagOf(x) === "item")) {
+          i++;
+          const body = blocks(kids(it).filter((x) => tagOf(x) !== "caption"), depth).join(" ");
+          if (body) out.push(`${ordered ? `${i}.` : "-"} ${body}`);
+        }
+        break;
+      }
+      case "table": {
+        const md = table(n);
+        if (md) out.push(md);
+        break;
+      }
+      case "renderMultiMedia":
+      case "observationMedia":
+      case "subject":
+        break;
+      case "section":
+        out.push(...section(n, depth));
+        break;
+      case "component":
+      case "text":
+      case "excerpt":
+      case "highlight":
+      default:
+        out.push(...blocks(c, depth));
+        break;
+    }
+  }
+  return out;
+}
+var SKIP_CODES = /* @__PURE__ */ new Set(["48780-1", "51945-4"]);
+var CODE_NAMES = { "34066-1": "Boxed Warning", "43683-2": "Recent Major Changes" };
+var plain2 = (nodes) => {
+  let out = "";
+  for (const n of nodes) out += "#text" in n ? String(n["#text"]) : tagOf(n) === "br" ? " " : plain2(kids(n));
+  return out;
+};
+function section(n, depth) {
+  const code = child(n, "code");
+  const c = code ? attr(code, "code") : "";
+  if (SKIP_CODES.has(c)) return [];
+  const title = child(n, "title");
+  let head = title ? squash(plain2(kids(title))) : "";
+  if (c === "34066-1" && head && !/boxed warning/i.test(head)) head = `Boxed Warning: ${head}`;
+  if (!head && CODE_NAMES[c]) head = CODE_NAMES[c];
+  const out = [];
+  if (head) out.push(`${"#".repeat(Math.min(depth, 6))} ${head}`);
+  const rest = kids(n).filter((x) => !["title", "code", "id", "effectiveTime"].includes(tagOf(x)));
+  out.push(...blocks(rest, head ? depth + 1 : depth));
+  return out;
+}
+var isoDate = (v) => /^\d{8}$/.test(v) ? `${v.slice(0, 4)}-${v.slice(4, 6)}-${v.slice(6, 8)}` : v || null;
+function parseSpl(xml) {
+  const doc = parser2.parse(xml);
+  const d = doc.find((x) => tagOf(x) === "document");
+  if (!d) return null;
+  const k = kids(d);
+  const setid = attr(child(d, "setId") ?? {}, "root").toLowerCase();
+  const version = attr(child(d, "versionNumber") ?? {}, "value") || null;
+  const effective = isoDate(attr(child(d, "effectiveTime") ?? {}, "value"));
+  const named = (nodes) => {
+    for (const n of nodes) {
+      if ("#text" in n) continue;
+      if (tagOf(n) === "manufacturedProduct") {
+        const inner2 = child(n, "manufacturedProduct") ?? n;
+        if (child(inner2, "name")) return inner2;
+      }
+      const h = named(kids(n));
+      if (h) return h;
+    }
+    return void 0;
+  };
+  const inner = named(k);
+  const brand = inner ? squash(inline(kids(child(inner, "name") ?? { name: [] }))) || null : null;
+  const genericNode = inner ? findDeep(kids(inner), "genericMedicine") : void 0;
+  const generic = genericNode ? squash(inline(kids(child(genericNode, "name") ?? { name: [] }))) || null : null;
+  const formNode = inner ? child(inner, "formCode") : void 0;
+  const form = formNode ? attr(formNode, "displayName").toLowerCase() || null : null;
+  const org = findDeep(k, "representedOrganization");
+  const labeler = org ? squash(inline(kids(child(org, "name") ?? { name: [] }))) || null : null;
+  const body = findDeep(k, "structuredBody");
+  const sections2 = body ? blocks(kids(body), 2) : [];
+  const docTitle = child(d, "title");
+  const lines = [];
+  let cur = "";
+  for (const x of docTitle ? kids(docTitle) : []) {
+    if (!("#text" in x) && tagOf(x) === "br") {
+      lines.push(cur);
+      cur = "";
+    } else cur += "#text" in x ? String(x["#text"]) : inline([x]);
+  }
+  lines.push(cur);
+  const highlights = lines.map(squash).filter((l) => l && !/^these highlights do not include/i.test(l) && !/^see full prescribing information/i.test(l)).map((l) => l.replace(/^see full prescribing information for [^.]+\.\s*/i, "")).filter(Boolean);
+  const approvalYear = /initial u\.?s\.? approval:?\s*(\d{4})/i.exec(highlights.join(" "))?.[1] ?? null;
+  const productLine = highlights.find((l) => !/initial u\.?s\.? approval/i.test(l)) ?? null;
+  const title = [brand, generic ? `(${generic})` : "", form].filter(Boolean).join(" ") || productLine || setid;
+  return { setid, version, effective, brand, generic, form, labeler, title: `${title} \u2014 prescribing information`, highlights, approvalYear, sections: sections2 };
+}
+function headLineSpl(s) {
+  return [s.labeler, `DailyMed set ID ${s.setid}`, s.version ? `version ${s.version}` : "", s.effective ? `effective ${s.effective}` : "", s.approvalYear ? `initial U.S. approval ${s.approvalYear}` : "", DAILYMED_PAGE(s.setid)].filter(Boolean).join(" \xB7 ");
+}
+function renderLabelMd(s) {
+  const parts = [`# ${s.title}`, "", headLineSpl(s), ""];
+  if (s.highlights.length) parts.push("## Highlights", "", ...s.highlights.flatMap((l) => [l, ""]));
+  parts.push(...s.sections.flatMap((b) => [b, ""]));
+  return parts.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+// src/ctgov.ts
+var CTGOV_PAGE = (nctid) => `https://clinicaltrials.gov/study/${nctid}`;
+var API = (nctid) => `https://clinicaltrials.gov/api/v2/studies/${nctid}?format=json`;
+async function fetchStudy(nctid) {
+  const json2 = await fetchText(API(nctid), { "User-Agent": LIBRARY_UA, Accept: "application/json" });
+  if (!/"protocolSection"/.test(json2.slice(0, 2e3))) throw new Error("ctgov: not a study record");
+  return json2;
+}
+var STATUS = {
+  NOT_YET_RECRUITING: "Not yet recruiting",
+  RECRUITING: "Recruiting",
+  ENROLLING_BY_INVITATION: "Enrolling by invitation",
+  ACTIVE_NOT_RECRUITING: "Active, not recruiting",
+  SUSPENDED: "Suspended",
+  TERMINATED: "Terminated",
+  COMPLETED: "Completed",
+  WITHDRAWN: "Withdrawn",
+  UNKNOWN: "Unknown status",
+  AVAILABLE: "Available",
+  NO_LONGER_AVAILABLE: "No longer available",
+  TEMPORARILY_NOT_AVAILABLE: "Temporarily not available",
+  APPROVED_FOR_MARKETING: "Approved for marketing",
+  WITHHELD: "Withheld"
+};
+var PHASE = { EARLY_PHASE1: "Early Phase 1", PHASE1: "Phase 1", PHASE2: "Phase 2", PHASE3: "Phase 3", PHASE4: "Phase 4", NA: "Not applicable" };
+var words = (v) => {
+  const s = String(v ?? "");
+  if (!s) return "";
+  if (STATUS[s]) return STATUS[s];
+  if (PHASE[s]) return PHASE[s];
+  const w = s.toLowerCase().replace(/_/g, " ");
+  return w.charAt(0).toUpperCase() + w.slice(1);
+};
+var dated = (d) => d?.date ? `${d.date}${d.type ? ` (${String(d.type).toLowerCase()})` : ""}` : "";
+var list = (a) => Array.isArray(a) ? a : [];
+var row = (cells) => `| ${cells.map((c) => c.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim()).join(" | ")} |`;
+var table2 = (head, rows) => rows.length ? [row(head), `| ${head.map(() => "---").join(" | ")} |`, ...rows.map(row)].join("\n") : "";
+var para = (s) => String(s ?? "").replace(/\r/g, "").trim();
+function parseStudy(json2) {
+  let d;
   try {
-    return JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+    d = JSON.parse(json2);
   } catch {
-    return { name: "ai4l-library", version: "0.0.0" };
+    return null;
   }
-})();
-var INSTRUCTIONS = `ai4l-library builds a local library of the scientific papers cited by evidence reviews. Given a paper ID ("type:value", e.g. pmid:30955454; bare digits count as pmid) it fetches the paper's record and stores it as files under the library directory. Nothing flows through your context: the server writes to disk itself and returns only a small JSON status per call. One ID per call \u2014 no batches.
+  const ps = d?.protocolSection;
+  if (!ps) return null;
+  const idm = ps.identificationModule ?? {}, st = ps.statusModule ?? {}, sp = ps.sponsorCollaboratorsModule ?? {}, de = ps.descriptionModule ?? {};
+  const dm = ps.designModule ?? {}, ai = ps.armsInterventionsModule ?? {}, om = ps.outcomesModule ?? {}, el = ps.eligibilityModule ?? {}, cl = ps.contactsLocationsModule ?? {}, rf = ps.referencesModule ?? {};
+  const nctid = String(idm.nctId ?? "").toUpperCase();
+  const out = [];
+  const sec = (title, lines) => {
+    const body = lines.filter((l) => !!l && l.trim() !== "");
+    if (body.length) out.push(`## ${title}`, ...body);
+  };
+  const secondary = list(idm.secondaryIdInfos).map((s) => `${words(s.type)}${s.domain ? ` (${s.domain})` : ""}: ${s.id}`);
+  sec("Identification", [
+    idm.officialTitle ? `Official title: ${para(idm.officialTitle)}` : null,
+    idm.acronym ? `Acronym: ${idm.acronym}` : null,
+    idm.organization?.fullName ? `Organization: ${idm.organization.fullName}` : null,
+    secondary.length ? `Secondary IDs: ${secondary.join("; ")}` : null
+  ]);
+  sec("Status", [
+    `Overall status: ${words(st.overallStatus)}${st.whyStopped ? ` \u2014 why stopped: ${para(st.whyStopped)}` : ""}`,
+    st.startDateStruct ? `Start: ${dated(st.startDateStruct)}` : null,
+    st.primaryCompletionDateStruct ? `Primary completion: ${dated(st.primaryCompletionDateStruct)}` : null,
+    st.completionDateStruct ? `Completion: ${dated(st.completionDateStruct)}` : null,
+    st.studyFirstPostDateStruct ? `First posted: ${dated(st.studyFirstPostDateStruct)}` : null,
+    st.lastUpdatePostDateStruct ? `Last update posted: ${dated(st.lastUpdatePostDateStruct)}` : null,
+    st.statusVerifiedDate ? `Status verified: ${st.statusVerifiedDate}` : null,
+    `Results posted: ${d.hasResults ? "yes" : "no"}`
+  ]);
+  const rp = sp.responsibleParty;
+  sec("Sponsor and collaborators", [
+    sp.leadSponsor?.name ? `Lead sponsor: ${sp.leadSponsor.name}${sp.leadSponsor.class ? ` (${words(sp.leadSponsor.class).toLowerCase()})` : ""}` : null,
+    list(sp.collaborators).length ? `Collaborators: ${list(sp.collaborators).map((c) => c.name).join("; ")}` : null,
+    rp ? `Responsible party: ${[words(rp.type).toLowerCase(), rp.investigatorFullName, rp.investigatorTitle, rp.investigatorAffiliation].filter(Boolean).join(", ")}` : null
+  ]);
+  sec("Description", [de.briefSummary ? para(de.briefSummary) : null, de.detailedDescription ? para(de.detailedDescription) : null]);
+  sec("Conditions", [list(ps.conditionsModule?.conditions).length ? list(ps.conditionsModule.conditions).join("; ") : null, list(ps.conditionsModule?.keywords).length ? `Keywords: ${list(ps.conditionsModule.keywords).join("; ")}` : null]);
+  const di = dm.designInfo ?? {};
+  const mi = di.maskingInfo ?? {};
+  sec("Design", [
+    dm.studyType ? `Study type: ${words(dm.studyType)}` : null,
+    list(dm.phases).length ? `Phase: ${list(dm.phases).map(words).join(", ")}` : null,
+    di.allocation ? `Allocation: ${words(di.allocation)}` : null,
+    di.interventionModel ? `Intervention model: ${words(di.interventionModel)}${di.interventionModelDescription ? ` \u2014 ${para(di.interventionModelDescription)}` : ""}` : null,
+    di.primaryPurpose ? `Primary purpose: ${words(di.primaryPurpose)}` : null,
+    mi.masking ? `Masking: ${words(mi.masking)}${list(mi.whoMasked).length ? ` (${list(mi.whoMasked).map((w) => words(w).toLowerCase()).join(", ")})` : ""}${mi.maskingDescription ? ` \u2014 ${para(mi.maskingDescription)}` : ""}` : null,
+    dm.enrollmentInfo?.count !== void 0 ? `Enrollment: ${dm.enrollmentInfo.count}${dm.enrollmentInfo.type ? ` (${String(dm.enrollmentInfo.type).toLowerCase()})` : ""}` : null
+  ]);
+  const arms = list(ai.armGroups).map((a) => `- **${a.label}**${a.type ? ` (${words(a.type).toLowerCase()})` : ""}${a.description ? `: ${para(a.description)}` : ""}${list(a.interventionNames).length ? ` \u2014 ${list(a.interventionNames).join("; ")}` : ""}`);
+  const ints = list(ai.interventions).map((i) => `- **${words(i.type)}: ${i.name}**${list(i.otherNames).length ? ` (${list(i.otherNames).join(", ")})` : ""}${i.description ? `: ${para(i.description)}` : ""}${list(i.armGroupLabels).length ? ` \u2014 arms: ${list(i.armGroupLabels).join("; ")}` : ""}`);
+  sec("Arms and interventions", [arms.length ? "Arms:" : null, ...arms, ints.length ? "Interventions:" : null, ...ints]);
+  const outcome = (o) => `- **${para(o.measure)}**${o.description ? `: ${para(o.description)}` : ""}${o.timeFrame ? ` Time frame: ${para(o.timeFrame)}.` : ""}`;
+  sec("Outcomes", [
+    list(om.primaryOutcomes).length ? "### Primary outcomes" : null,
+    ...list(om.primaryOutcomes).map(outcome),
+    list(om.secondaryOutcomes).length ? "### Secondary outcomes" : null,
+    ...list(om.secondaryOutcomes).map(outcome),
+    list(om.otherOutcomes).length ? "### Other outcomes" : null,
+    ...list(om.otherOutcomes).map(outcome)
+  ]);
+  sec("Eligibility", [
+    [el.sex ? `Sex: ${words(el.sex).toLowerCase()}` : "", el.minimumAge || el.maximumAge ? `Age: ${el.minimumAge ?? "no minimum"} to ${el.maximumAge ?? "no maximum"}` : "", el.healthyVolunteers !== void 0 ? `Healthy volunteers: ${el.healthyVolunteers ? "yes" : "no"}` : ""].filter(Boolean).join(" \xB7 "),
+    el.eligibilityCriteria ? para(el.eligibilityCriteria) : null
+  ]);
+  const countries = [...new Set(list(cl.locations).map((l) => l.country).filter(Boolean))];
+  sec("Locations", [countries.length ? `${list(cl.locations).length} sites in ${countries.join(", ")}` : null, list(cl.overallOfficials).length ? `Overall officials: ${list(cl.overallOfficials).map((o) => [o.name, o.role ? words(o.role).toLowerCase() : "", o.affiliation].filter(Boolean).join(", ")).join("; ")}` : null]);
+  const refs = list(rf.references);
+  sec("References", refs.map((r) => `- ${para(r.citation)}${r.pmid ? ` pmid:${r.pmid}` : ""}${r.type ? ` (${words(r.type).toLowerCase()})` : ""}`));
+  const publications = refs.filter((r) => r.pmid && ["RESULT", "DERIVED"].includes(String(r.type))).map((r) => `pmid:${r.pmid}`);
+  if (d.hasResults && d.resultsSection) out.push(...results(d.resultsSection));
+  return {
+    nctid,
+    title: para(idm.briefTitle) || nctid,
+    acronym: idm.acronym ?? null,
+    sponsor: sp.leadSponsor?.name ?? null,
+    firstPosted: st.studyFirstPostDateStruct?.date ?? null,
+    lastUpdate: st.lastUpdatePostDateStruct?.date ?? null,
+    status: st.overallStatus ? words(st.overallStatus) : null,
+    hasResults: !!d.hasResults,
+    publications,
+    sections: out
+  };
+}
+function results(rs) {
+  const out = ["## Results"];
+  const pf = rs.participantFlowModule;
+  if (pf) {
+    out.push("### Participant flow");
+    const groups = list(pf.groups);
+    out.push(...groups.map((g) => `- **${g.title}**${g.description ? `: ${para(g.description)}` : ""}`));
+    if (pf.recruitmentDetails) out.push(para(pf.recruitmentDetails));
+    for (const p of list(pf.periods)) {
+      const head = ["Period: " + (p.title ?? ""), ...groups.map((g) => g.title)];
+      const rows = list(p.milestones).map((m) => [words(m.type), ...groups.map((g) => list(m.achievements).find((a) => a.groupId === g.id)?.numSubjects ?? "")]);
+      for (const dw of list(p.dropWithdraws)) rows.push([`Not completed: ${dw.type}`, ...groups.map((g) => list(dw.reasons).find((r) => r.groupId === g.id)?.numSubjects ?? "")]);
+      out.push(table2(head, rows));
+    }
+  }
+  const bc = rs.baselineCharacteristicsModule;
+  if (bc) {
+    out.push("### Baseline characteristics");
+    const groups = list(bc.groups);
+    out.push(...groups.map((g) => `- **${g.title}**${g.description ? `: ${para(g.description)}` : ""}`));
+    for (const m of list(bc.measures)) {
+      const unit = [m.paramType ? words(m.paramType).toLowerCase() : "", m.dispersionType ? words(m.dispersionType).toLowerCase() : "", m.unitOfMeasure].filter(Boolean).join(", ");
+      const rows = [];
+      for (const c of list(m.classes)) for (const cat of list(c.categories)) rows.push([[c.title, cat.title].filter(Boolean).join(" \u2014 ") || m.title, ...groups.map((g) => {
+        const x = list(cat.measurements).find((v) => v.groupId === g.id);
+        return x ? `${x.value ?? ""}${x.spread !== void 0 ? ` \xB1 ${x.spread}` : ""}${x.lowerLimit !== void 0 ? ` (${x.lowerLimit} to ${x.upperLimit})` : ""}` : "";
+      })]);
+      out.push(`**${m.title}**${unit ? ` (${unit})` : ""}`, table2(["", ...groups.map((g) => g.title)], rows));
+    }
+  }
+  const om = rs.outcomeMeasuresModule;
+  if (om) {
+    out.push("### Outcome measures");
+    for (const m of list(om.outcomeMeasures)) {
+      const groups = list(m.groups);
+      const unit = [m.paramType ? words(m.paramType).toLowerCase() : "", m.dispersionType ? String(m.dispersionType).toLowerCase() : "", m.unitOfMeasure].filter(Boolean).join(", ");
+      out.push(`#### ${m.title}${m.type ? ` (${words(m.type).toLowerCase()})` : ""}`);
+      if (m.description) out.push(para(m.description));
+      out.push([m.timeFrame ? `Time frame: ${para(m.timeFrame)}.` : "", unit ? `Measure: ${unit}.` : "", m.populationDescription ? `Population: ${para(m.populationDescription)}` : ""].filter(Boolean).join(" "));
+      if (m.reportingStatus && m.reportingStatus !== "POSTED") out.push(`Reporting status: ${words(m.reportingStatus)}.`);
+      const rows = [];
+      for (const c of list(m.classes)) for (const cat of list(c.categories)) rows.push([[c.title, cat.title].filter(Boolean).join(" \u2014 ") || m.title, ...groups.map((g) => {
+        const x = list(cat.measurements).find((v) => v.groupId === g.id);
+        return x ? `${x.value ?? ""}${x.spread !== void 0 ? ` \xB1 ${x.spread}` : ""}${x.lowerLimit !== void 0 ? ` (${x.lowerLimit} to ${x.upperLimit})` : ""}` : "";
+      })]);
+      const denoms = list(m.denoms).flatMap((dn) => list(dn.counts)).filter((c) => c.groupId);
+      if (denoms.length) rows.unshift(["Participants analysed", ...groups.map((g) => denoms.find((c) => c.groupId === g.id)?.value ?? "")]);
+      out.push(table2(["", ...groups.map((g) => g.title)], rows));
+      for (const a of list(m.analyses)) out.push(`Analysis${a.groupDescription ? ` (${para(a.groupDescription)})` : ""}: ${[a.statisticalMethod, a.pValue !== void 0 ? `p ${a.pValueComment ?? ""}${a.pValue}`.trim() : "", a.paramType ? `${words(a.paramType).toLowerCase()} ${a.paramValue ?? ""}` : "", a.ciPctValue ? `${a.ciPctValue}% CI ${a.ciLowerLimit ?? ""} to ${a.ciUpperLimit ?? ""}` : ""].filter(Boolean).join("; ")}`);
+    }
+  }
+  const ae = rs.adverseEventsModule;
+  if (ae) {
+    out.push("### Adverse events");
+    const groups = list(ae.eventGroups);
+    out.push([ae.timeFrame ? `Time frame: ${para(ae.timeFrame)}.` : "", ae.frequencyThreshold ? `Threshold for other events: ${ae.frequencyThreshold}%.` : "", ae.description ? para(ae.description) : ""].filter(Boolean).join(" "));
+    const summary = [
+      ["Serious events, participants affected / at risk", ...groups.map((g) => `${g.seriousNumAffected ?? ""} / ${g.seriousNumAtRisk ?? ""}`)],
+      ["Other events, participants affected / at risk", ...groups.map((g) => `${g.otherNumAffected ?? ""} / ${g.otherNumAtRisk ?? ""}`)],
+      ["Deaths, participants affected / at risk", ...groups.map((g) => g.deathsNumAffected !== void 0 ? `${g.deathsNumAffected} / ${g.deathsNumAtRisk ?? ""}` : "")]
+    ].filter((r) => r.slice(1).some(Boolean));
+    out.push(table2(["", ...groups.map((g) => g.title)], summary));
+    const events = (title, evs) => {
+      if (!evs.length) return;
+      out.push(`**${title}** (participants affected / at risk)`, table2(["Event", "System", ...groups.map((g) => g.title)], evs.map((e) => [e.term ?? "", e.organSystem ?? "", ...groups.map((g) => {
+        const s = list(e.stats).find((x) => x.groupId === g.id);
+        return s ? `${s.numAffected ?? ""} / ${s.numAtRisk ?? ""}` : "";
+      })])));
+    };
+    events("Serious adverse events", list(ae.seriousEvents));
+    events("Other adverse events", list(ae.otherEvents));
+  }
+  return out;
+}
+function headLineStudy(s) {
+  return [s.sponsor, s.nctid, s.status ? s.status.toLowerCase() : "", s.firstPosted ? `first posted ${s.firstPosted}` : "", s.lastUpdate ? `last update posted ${s.lastUpdate}` : "", CTGOV_PAGE(s.nctid)].filter(Boolean).join(" \xB7 ");
+}
+function renderStudyMd(s) {
+  const parts = [`# ${s.title}${s.acronym ? ` (${s.acronym})` : ""} \u2014 ClinicalTrials.gov record`, "", headLineStudy(s), "", ...s.sections.flatMap((b) => [b, ""])];
+  return parts.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
 
-Tools:
-- library_add(id) \u2014 build the entry for one ID and return its status. Idempotent: an existing entry is returned without any network call.
-- library_status(id) \u2014 read-only: the entry's status, or level "missing".
-- get_version() \u2014 package name, version and the resolved library directory.
+// src/pdf.ts
+import { getDocumentProxy } from "unpdf";
 
-Status JSON fields: requested, type, id, entry, entry_dir, library_dir, pmid, pmcid, doi, title, first_author, year, publication_types, retracted, level, version, retrieved_by, retrieved_date, attempts, files, and error when the call could not produce an entry ("invalid id", "type not supported yet", "pmid not found", or a fetch failure).
+// src/glyph-names.ts
+var PI_NAMES = {
+  H11001: "+",
+  H11002: "\u2212",
+  H11003: "\xD7",
+  H11005: "=",
+  H11006: "\xB1",
+  H11009: "\u221E",
+  H11011: "~",
+  H11015: "~",
+  H11021: "<",
+  H11022: ">",
+  H11032: "\u2032",
+  H11034: "\xB0",
+  H11349: "\u2264",
+  H11350: "\u2265",
+  H11545: "+",
+  H11549: "=",
+  H11554: "\u2022",
+  H11569: "*",
+  H17004: "\u25CF",
+  H17039: "\u25AA",
+  H20648: "\u2016",
+  H20841: "|",
+  H20851: "[",
+  H20852: "]",
+  H20862: "/",
+  H20873: "(",
+  H20874: ")",
+  H9004: "\u0394",
+  H9018: "\u03A3",
+  H9251: "\u03B1",
+  H9252: "\u03B2",
+  H9253: "\u03B3",
+  H9260: "\u03BA",
+  H9262: "\u03BC",
+  H9270: "\u03C4",
+  H9273: "\u03C7",
+  L1151: "+",
+  L1152: "\u2212",
+  L1154: "\xD7",
+  L50140: ">",
+  L50141: "<",
+  L50512: "\xB1",
+  L50871: "\u2265",
+  afii9797: "\u0394",
+  afii9825: "\u03B1",
+  afii9826: "\u03B2",
+  afii9839: "\u03BC",
+  Delta1: "\u0394",
+  "221e": "\u221E",
+  "223c": "~",
+  uni00b5: "\u03BC"
+};
+var FAMILY_NAMES = {
+  AdvP4C4E74: { C0: "\u2212", C1: ".", C2: "\xD7", C3: "*", C6: "\xB1", C15: "\u2022", C20: "\u2264", C21: "\u2265", C24: "~" },
+  AdvMT_SY: { C0: "\u2212", C2: "\xD7", C6: "\xB1" },
+  AdvMacMthSyN: { C0: "\u2212", C2: "\xD7", C6: "\xB1" }
+};
+var fontFamily = (name) => name.replace(/^[A-Z]{6}\+/, "").replace(/[+-].*$/, "");
+function glyphChar(fontName, glyph) {
+  return PI_NAMES[glyph] ?? FAMILY_NAMES[fontFamily(fontName)]?.[glyph] ?? null;
+}
+function emittedNames(differences) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [code, name] of differences) {
+    const m = /^C(\d{2,3})$/.exec(name);
+    const emitted = m ? Number(m[1]) : code;
+    if (emitted < 32) out.set(emitted, name);
+  }
+  return out;
+}
 
-v0.1: pmid: IDs only (other types return error "type not supported yet"); the pubmed tier only, so every entry is level "abstract" (efetch XML, abstract Markdown, meta).`;
-var idSchema = z.string().describe('Paper ID as "type:value", e.g. "pmid:30955454"; bare digits count as pmid.');
-var json = (s) => ({ content: [{ type: "text", text: JSON.stringify(s, null, 2) }] });
-function registerTools(server2) {
-  server2.tool(
-    "library_add",
-    "Build the library entry for one paper ID and return its status JSON. v0.1: pmid: only, pubmed tier only (level abstract). Idempotent \u2014 an existing entry is returned without refetching.",
-    { id: idSchema },
-    async ({ id }) => {
-      const parsed = parseId(id);
-      const status = emptyStatus(parsed.requested, parsed.type, parsed.id, LIBRARY_DIR);
-      if (parsed.error) return json({ ...status, error: parsed.error });
-      const paths = entryPaths(LIBRARY_DIR, parsed.type, parsed.id);
-      if (entryExists(paths)) return json(readStatus(paths, status));
-      let xml;
-      try {
-        xml = await fetchPubmedXml(parsed.id);
-      } catch (e) {
-        return json({ ...status, error: e instanceof Error ? e.message : String(e) });
-      }
-      const record = parsePubmedXml(xml);
-      if (!record) return json({ ...status, error: "pmid not found" });
-      writeEntry(paths, record, xml, `${pkg.name} ${pkg.version}`);
-      return json(readStatus(paths, status));
+// src/pdf.ts
+var SECTION_NAMES = [
+  "abstract",
+  "summary",
+  "background",
+  "introduction",
+  "method",
+  "methods",
+  "materials and methods",
+  "material and methods",
+  "methods and materials",
+  "subjects and methods",
+  "patients and methods",
+  "participants and methods",
+  "experimental",
+  "experimental section",
+  "experimental procedures",
+  "study design",
+  "study population",
+  "participants",
+  "procedure",
+  "procedures",
+  "statistical analysis",
+  "result",
+  "results",
+  "results and discussion",
+  "findings",
+  "discussion",
+  "conclusion",
+  "conclusions",
+  "limitations",
+  "references",
+  "acknowledgments",
+  "acknowledgements",
+  "funding",
+  "conflict of interest",
+  "conflicts of interest",
+  "supplementary material",
+  "supplementary information"
+];
+var squeeze = (s) => s.toLowerCase().replace(/&/g, "and").replace(/[^a-z]/g, "");
+var BY_SQUEEZED = new Map(SECTION_NAMES.map((n) => [squeeze(n), n.replace(/\b\w/g, (c) => c.toUpperCase())]));
+function headingOf(line) {
+  let bare2 = line.trim().replace(/^\d+(\.\d+)*\.?\s*[|.]?\s*/, "").replace(/\s*:$/, "").replace(/([A-Za-z])\d{1,4}$/, "$1");
+  if (bare2.length > 60 || !/^[A-Za-z][A-Za-z &]*$/.test(bare2)) return null;
+  return BY_SQUEEZED.get(squeeze(bare2)) ?? null;
+}
+async function pdfToMarkdown(bytes, title, headLine2, stats) {
+  const pdf = await getDocumentProxy(new Uint8Array(bytes), { fontExtraProperties: true });
+  const text3 = await extractPages(pdf);
+  if (stats) {
+    stats.pages = pdf.numPages;
+    stats.chars = text3.replace(/\s+/g, " ").trim().length;
+  }
+  const lines = text3.split(/\r?\n/).map((l) => l.replace(/\s+/g, " ").trim());
+  const out = [`# ${title}`, "", headLine2, ""];
+  let para2 = [];
+  const flush = () => {
+    if (para2.length) {
+      out.push(para2.join(" "), "");
+      para2 = [];
     }
-  );
-  server2.tool(
-    "library_status",
-    'Read-only status of the library entry for one paper ID: the same status JSON as library_add, or level "missing" when there is no entry. Never fetches.',
-    { id: idSchema },
-    async ({ id }) => {
-      const parsed = parseId(id);
-      const status = emptyStatus(parsed.requested, parsed.type, parsed.id, LIBRARY_DIR);
-      if (parsed.error) return json({ ...status, error: parsed.error });
-      const paths = entryPaths(LIBRARY_DIR, parsed.type, parsed.id);
-      if (entryExists(paths)) return json(readStatus(paths, status));
-      return json({ ...status, entry: paths.entry, entry_dir: paths.entryDir, level: "missing" });
+  };
+  for (const line of lines) {
+    if (!line) {
+      flush();
+      continue;
+    }
+    const h = headingOf(line);
+    if (h) {
+      flush();
+      out.push(`## ${h}`, "");
+      continue;
+    }
+    para2.push(line);
+  }
+  flush();
+  return fixGlyphs(out.join("\n")).replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+var CONTROL = /[\u0001-\u0008\u000b\u000c\u000e-\u001f]/;
+async function extractPages(pdf) {
+  const pages = [];
+  for (let i = 1; i <= pdf.numPages; i++) {
+    const page = await pdf.getPage(i);
+    const fonts = /* @__PURE__ */ new Map();
+    const fontOf = (loaded2) => {
+      if (!fonts.has(loaded2)) {
+        let f;
+        try {
+          f = page.commonObjs.get(loaded2);
+        } catch {
+          f = void 0;
+        }
+        fonts.set(loaded2, f?.differences instanceof Map ? { name: f.name ?? "", emitted: emittedNames(f.differences) } : null);
+      }
+      return fonts.get(loaded2) ?? null;
+    };
+    let loaded = false, text3 = "";
+    for (const it of (await page.getTextContent()).items) {
+      if (it.str == null) continue;
+      let s = it.str;
+      if (CONTROL.test(s) && it.fontName) {
+        if (!loaded) {
+          try {
+            await page.getOperatorList();
+          } catch {
+          }
+          loaded = true;
+        }
+        const font = fontOf(it.fontName);
+        if (font) s = s.replace(new RegExp(CONTROL.source, "g"), (ch) => {
+          const name = font.emitted.get(ch.charCodeAt(0));
+          return (name && glyphChar(font.name, name)) ?? ch;
+        });
+      }
+      text3 += s;
+      if (it.hasEOL) {
+        let i2 = text3.length;
+        while (i2 > 0 && (text3[i2 - 1] === " " || text3[i2 - 1] === "	")) i2--;
+        if (i2 >= 2 && text3[i2 - 1] === "-" && /[A-Za-z]/.test(text3[i2 - 2])) text3 = text3.slice(0, i2 - 1) + BREAK + text3.slice(i2);
+        text3 += "\n";
+      }
+    }
+    pages.push(text3);
+  }
+  return dehyphenate(pages.join("\n").replace(/[^\S\n]+/g, " ").replace(/ ?\n ?/g, "\n").replace(/\n{3,}/g, "\n\n"));
+}
+var BREAK = "\0";
+var SUSPENDED = /* @__PURE__ */ new Set(["and", "or", "to", "vs", "but", "nor"]);
+var COMPOUND_PREFIX = /* @__PURE__ */ new Set([
+  "anti",
+  "non",
+  "pre",
+  "post",
+  "self",
+  "meta",
+  "cross",
+  "long",
+  "short",
+  "high",
+  "low",
+  "well",
+  "placebo",
+  "double",
+  "single",
+  "randomized",
+  "randomised",
+  "multi",
+  "co",
+  "inter",
+  "intra",
+  "sub",
+  "semi",
+  "dose",
+  "time",
+  "age",
+  "sex",
+  "over",
+  "under",
+  "half",
+  "full",
+  "all",
+  "one",
+  "two",
+  "three",
+  "first",
+  "second",
+  "third",
+  "end",
+  "mid",
+  "late",
+  "early",
+  "whole",
+  "small",
+  "large",
+  "vitamin",
+  "omega",
+  "alpha",
+  "beta",
+  "gamma",
+  "type",
+  "wild",
+  "ex",
+  "quasi",
+  "pseudo",
+  "peri",
+  "re"
+]);
+function dehyphenate(text3) {
+  if (!text3.includes(BREAK)) return text3;
+  const lower = text3.toLowerCase();
+  const seen = (s) => new RegExp(`(?<![a-z])${s}(?![a-z])`).test(lower);
+  return text3.replace(/([A-Za-z]+)\u0000\n([A-Za-z]+)/g, (m, x, y) => {
+    if (!/^[a-z]/.test(y)) return `${x}-${y}`;
+    if (SUSPENDED.has(y.toLowerCase())) return `${x}- ${y}`;
+    const hyph = `${x}-${y}`.toLowerCase(), joined = `${x}${y}`.toLowerCase();
+    if (seen(hyph)) return `${x}-${y}`;
+    if (seen(joined)) return `${x}${y}`;
+    return COMPOUND_PREFIX.has(x.toLowerCase()) ? `${x}-${y}` : `${x}${y}`;
+  }).replace(/\u0000\n/g, "-\n").replace(/\u0000/g, "-");
+}
+function fixGlyphs(md) {
+  return md.replace(/¡(?=\.?\d)/g, "\u2212").replace(/(?<=[\p{L}\p{N}])\u0008(?=[\p{L}\p{N}])/gu, " ");
+}
+var UNRESOLVED_GLYPH = /[\u0001-\u0008\u000b\u000c\u000e-\u001f]/g;
+var countUnresolved = (text3) => (text3.match(UNRESOLVED_GLYPH) ?? []).length;
+var looksLikePdf = (bytes) => bytes.subarray(0, 5).toString("latin1") === "%PDF-";
+
+// src/entry.ts
+function emptyStatus(requested, type, id, libraryDir) {
+  return {
+    requested,
+    type,
+    id,
+    entry: null,
+    entry_dir: null,
+    library_dir: libraryDir,
+    pmid: null,
+    setid: null,
+    nctid: null,
+    publications: [],
+    pmcid: null,
+    doi: null,
+    title: null,
+    first_author: null,
+    year: null,
+    publication_types: [],
+    retracted: false,
+    corrections: [],
+    coi: null,
+    funding: [],
+    citable: true,
+    comment: null,
+    has_abstract: null,
+    level: null,
+    version: null,
+    retrieved_by: null,
+    retrieved_date: null,
+    pubmed_checked: null,
+    attempts: [],
+    files: [],
+    glyphs_unresolved: null
+  };
+}
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+function headLine(r) {
+  return [
+    r.authors.join(", ") || null,
+    r.journal,
+    r.year,
+    r.pmid ? `PMID ${r.pmid}` : "not in PubMed",
+    r.doi ? `DOI ${r.doi}` : null,
+    r.pmcid ? `PMCID ${r.pmcid}` : null
+  ].filter(Boolean).join(" \xB7 ");
+}
+function renderAbstractMd(r) {
+  const body = r.abstract.length ? r.abstract.map((a) => a.label ? `**${a.label}.** ${a.text}` : a.text).join("\n\n") : "_No abstract available._";
+  return `# ${r.title}
+
+${headLine(r)}
+
+## Abstract
+
+${body}
+`;
+}
+function readHeadLine(p) {
+  try {
+    const lines = readFileSync3(p.md, "utf8").split("\n").filter((l) => l.trim());
+    return lines[1] ?? "";
+  } catch {
+    return "";
+  }
+}
+function metaFromRecord(r, files, converter) {
+  return {
+    pmid: r.pmid,
+    setid: null,
+    nctid: null,
+    publications: [],
+    pmcid: r.pmcid,
+    doi: r.doi,
+    title: r.title,
+    first_author: r.firstAuthor,
+    year: r.year,
+    publication_types: r.publicationTypes,
+    retracted: isRetracted(r),
+    corrections: r.corrections,
+    coi: r.coi,
+    funding: r.funding,
+    has_abstract: r.abstract.length > 0,
+    level: "abstract",
+    version: null,
+    files,
+    retrieved_by: "pubmed",
+    retrieved_date: today(),
+    converted_by: converter,
+    pubmed_checked: today(),
+    attempts: []
+  };
+}
+var isRetracted = (r) => r.publicationTypes.includes("Retracted Publication") || r.corrections.some(isRetractionNotice);
+var renderCorrection = (c) => `${c.type} ${c.pmid ?? "-"} ${JSON.stringify(c.source)}`;
+function parseCorrection(v) {
+  const m = /^(\S+) (\S+) ("[\s\S]*")$/.exec(v.trim());
+  if (!m) return null;
+  let source;
+  try {
+    source = JSON.parse(m[3]);
+  } catch {
+    return null;
+  }
+  return { type: m[1], pmid: m[2] === "-" ? null : m[2], source };
+}
+function renderMeta(m) {
+  const lines = [
+    ["pmid", m.pmid],
+    ...m.setid ? [["setid", m.setid]] : [],
+    ...m.nctid ? [["nctid", m.nctid]] : [],
+    ...m.nctid ? [["publications", m.publications.join(", ")]] : [],
+    ["pmcid", m.pmcid ?? ""],
+    ["doi", m.doi ?? ""],
+    ["title", JSON.stringify(m.title)],
+    ["first_author", m.first_author ?? ""],
+    ["year", m.year ?? ""],
+    ["publication_types", m.publication_types.join("; ")],
+    ["retracted", m.retracted ? "yes" : "no"],
+    ...m.corrections.map((c) => ["corrections", renderCorrection(c)]),
+    ["coi", m.coi === null ? "" : JSON.stringify(m.coi)],
+    ["funding", m.funding.length ? JSON.stringify(m.funding) : ""],
+    // a JSON array: a statement may hold semicolons
+    ["has_abstract", m.has_abstract ? "yes" : "no"],
+    ["level", m.level],
+    ["version", m.version ?? ""],
+    ["files", m.files.join(", ")],
+    ["retrieved_by", m.retrieved_by],
+    ["retrieved_date", m.retrieved_date],
+    ["converted_by", m.converted_by],
+    ["pubmed_checked", m.pubmed_checked],
+    ["attempts", m.attempts.join(", ")]
+  ];
+  return "---\n" + lines.map(([k, v]) => v === "" ? `${k}:` : `${k}: ${v}`).join("\n") + "\n---\n";
+}
+function parseFrontmatter(md) {
+  const m = /^---\n([\s\S]*?)\n---/.exec(md);
+  const fm = {}, all = {};
+  for (const line of (m?.[1] ?? "").split("\n")) {
+    const i = line.indexOf(":");
+    if (i <= 0) continue;
+    const k = line.slice(0, i).trim(), v = line.slice(i + 1).trim();
+    fm[k] = v;
+    (all[k] ??= []).push(v);
+  }
+  return { fm, all };
+}
+var list2 = (v) => v ? v.split(",").map((s) => s.trim()).filter(Boolean) : [];
+function splitAttempts(v) {
+  if (!v) return [];
+  const out = [];
+  let cur = "", depth = 0;
+  for (const ch of v) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  out.push(cur);
+  const merged = [];
+  for (const piece of out.map((s) => s.trim()).filter(Boolean)) {
+    if (merged.length && !/^\S+ \(/.test(piece)) merged[merged.length - 1] += ", " + piece;
+    else merged.push(piece);
+  }
+  return merged;
+}
+var opt = (v) => v ? v : null;
+var TYPE_CONTINUATION = /* @__PURE__ */ new Set(["N.I.H.", "Extramural", "Intramural", "Non-U.S. Gov't", "U.S. Gov't", "U.S. Government", "P.H.S.", "Non-P.H.S.", "Phase I", "Phase II", "Phase III", "Phase IV", "Veterinary", "NIH", "American Recovery and Reinvestment Act"]);
+function splitPublicationTypes(v) {
+  if (!v) return [];
+  if (v.includes(";")) return v.split(";").map((s) => s.trim()).filter(Boolean);
+  const out = [];
+  for (const piece of list2(v)) {
+    if (out.length && TYPE_CONTINUATION.has(piece)) out[out.length - 1] += ", " + piece;
+    else out.push(piece);
+  }
+  return out;
+}
+function abstractMissing(p) {
+  try {
+    return readFileSync3(p.md, "utf8").includes("_No abstract available._");
+  } catch {
+    return false;
+  }
+}
+function correctionsFromXml(p) {
+  try {
+    return parsePubmedXml(readFileSync3(p.xml, "utf8"))?.corrections ?? [];
+  } catch {
+    return [];
+  }
+}
+function declarationsFromXml(p) {
+  try {
+    const r = parsePubmedXml(readFileSync3(p.xml, "utf8"));
+    return { coi: r?.coi ?? null, funding: r?.funding ?? [] };
+  } catch {
+    return { coi: null, funding: [] };
+  }
+}
+function readMeta(p) {
+  const { fm, all } = parseFrontmatter(readFileSync3(p.meta, "utf8"));
+  let title = fm.title ?? "";
+  if (title.startsWith('"')) {
+    try {
+      title = JSON.parse(title);
+    } catch {
+    }
+  }
+  const legacy = fm.pubmed_checked === void 0;
+  const corrections = legacy ? correctionsFromXml(p) : (all.corrections ?? []).map(parseCorrection).filter((c) => c !== null);
+  let coi = null, funding = [];
+  if (fm.coi === void 0) ({ coi, funding } = declarationsFromXml(p));
+  else {
+    if (fm.coi.startsWith('"')) {
+      try {
+        coi = JSON.parse(fm.coi);
+      } catch {
+        coi = fm.coi;
+      }
+    } else coi = fm.coi || null;
+    funding = !fm.funding ? [] : fm.funding.startsWith("[") ? JSON.parse(fm.funding) : fm.funding.split(";").map((s) => s.trim()).filter(Boolean);
+  }
+  return {
+    pmid: fm.pmid ?? "",
+    setid: opt(fm.setid),
+    nctid: opt(fm.nctid),
+    publications: list2(fm.publications),
+    pmcid: opt(fm.pmcid),
+    doi: opt(fm.doi),
+    title,
+    first_author: opt(fm.first_author),
+    year: opt(fm.year),
+    publication_types: splitPublicationTypes(fm.publication_types),
+    retracted: fm.retracted === "yes" || corrections.some(isRetractionNotice),
+    corrections,
+    coi,
+    funding,
+    has_abstract: fm.has_abstract ? fm.has_abstract === "yes" : !abstractMissing(p),
+    level: fm.level === "full_text" ? "full_text" : "abstract",
+    version: opt(fm.version),
+    files: list2(fm.files),
+    retrieved_by: fm.retrieved_by ?? "",
+    retrieved_date: fm.retrieved_date ?? "",
+    converted_by: fm.converted_by ?? "",
+    pubmed_checked: legacy ? fm.retrieved_date ?? "" : fm.pubmed_checked,
+    attempts: splitAttempts(fm.attempts)
+  };
+}
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  writeFileSync(tmp, data);
+  renameSync(tmp, file);
+}
+function writeMeta(p, m) {
+  writeAtomic(p.meta, renderMeta(m));
+}
+function copyEntry(from, to) {
+  const tmp = `${to.entryDir}.${process.pid}.tmp`, old = `${to.entryDir}.${process.pid}.old`;
+  rmSync(tmp, { recursive: true, force: true });
+  mkdirSync(tmp, { recursive: true });
+  const rename = (n) => n.startsWith(from.entry) ? to.entry + n.slice(from.entry.length) : n;
+  for (const n of readdirSync(from.entryDir)) if (join4(from.entryDir, n) !== from.meta && !n.endsWith(".tmp")) copyFileSync(join4(from.entryDir, n), join4(tmp, rename(n)));
+  const m = readMeta(from);
+  const copy = { ...m, files: m.files.map(rename) };
+  writeFileSync(join4(tmp, basename(to.meta)), renderMeta(copy));
+  mkdirSync(dirname(to.entryDir), { recursive: true });
+  if (existsSync4(to.entryDir)) renameSync(to.entryDir, old);
+  renameSync(tmp, to.entryDir);
+  rmSync(old, { recursive: true, force: true });
+  return copy;
+}
+function citability(m) {
+  const of = (t) => m.corrections.filter((c) => c.type === t);
+  const cite = (c) => `${c.source}${c.pmid ? ` (pmid:${c.pmid})` : ""}`;
+  if (m.retracted) {
+    const r = m.corrections.filter(isRetractionNotice);
+    return { citable: false, comment: r.length ? `retracted: ${r.map(cite).join("; ")}` : "retracted (PubMed publication type)" };
+  }
+  const notes = [
+    ...of("erratum_in").map((c) => `erratum, not assessed: ${cite(c)}`),
+    ...of("expression_of_concern_in").map((c) => `expression of concern: ${cite(c)}`),
+    ...of("update_in").map((c) => `superseded by a newer version: ${cite(c)}`)
+  ];
+  return { citable: true, comment: notes.length ? notes.join("; ") : null };
+}
+function statusFromMeta(p, m, base) {
+  const full = existsSync4(p.fulltextMd) ? readFileSync3(p.fulltextMd, "utf8") : null;
+  const cit = citability(m);
+  if (full?.includes(`
+${CORRECTED_HEADING}
+`) && cit.comment) cit.comment = cit.comment.replace(/erratum, not assessed: /g, "erratum, corrected figures stored (Corrected in PubMed abstract): ");
+  return {
+    ...base,
+    entry: p.entry,
+    entry_dir: p.entryDir,
+    pmid: m.pmid || null,
+    setid: m.setid,
+    nctid: m.nctid,
+    publications: m.publications,
+    pmcid: m.pmcid,
+    doi: m.doi,
+    title: m.title || null,
+    first_author: m.first_author,
+    year: m.year,
+    publication_types: m.publication_types,
+    retracted: m.retracted,
+    corrections: m.corrections,
+    coi: m.coi,
+    funding: m.funding,
+    ...cit,
+    // What the entry holds: full_text, abstract, or only the title (the meta's
+    // level is "abstract" until a full text arrives; has_abstract says whether
+    // there is abstract text).
+    has_abstract: m.has_abstract,
+    level: m.level === "abstract" && !m.has_abstract ? "title" : m.level,
+    version: m.version,
+    retrieved_by: m.retrieved_by || null,
+    retrieved_date: m.retrieved_date || null,
+    pubmed_checked: m.pubmed_checked || null,
+    attempts: m.attempts,
+    files: m.files,
+    glyphs_unresolved: full === null ? null : countUnresolved(full)
+  };
+}
+function readStatus(p, base) {
+  return statusFromMeta(p, readMeta(p), base);
+}
+function entryExists(p) {
+  return existsSync4(p.meta);
+}
+function writeEntry(p, r, xml, converter) {
+  mkdirSync(p.entryDir, { recursive: true });
+  writeAtomic(p.xml, xml);
+  writeAtomic(p.md, renderAbstractMd(r));
+  const meta = metaFromRecord(r, [basename(p.xml), basename(p.md)], converter);
+  writeMeta(p, meta);
+  return meta;
+}
+function refreshRecord(p, m, r, xml) {
+  writeAtomic(p.xml, xml);
+  syncCorrectedBlock(p);
+  const next = {
+    ...m,
+    pmcid: r.pmcid ?? m.pmcid,
+    doi: r.doi ?? m.doi,
+    publication_types: r.publicationTypes,
+    retracted: isRetracted(r),
+    corrections: r.corrections,
+    coi: r.coi ?? m.coi,
+    funding: r.funding.length ? r.funding : m.funding,
+    // the paper's own statements stay when PubMed has none
+    pubmed_checked: today()
+  };
+  writeMeta(p, next);
+  return next;
+}
+function daysSince(date, now = /* @__PURE__ */ new Date()) {
+  const t = new Date(date).getTime();
+  return Number.isFinite(t) ? (now.getTime() - t) / 864e5 : Infinity;
+}
+var FUNDING_RE = /^[*_\s]*(funding|financial support|sources? of (financial )?support|support(ed by)?|grant support|this (work|study|research) was (supported|funded))\b[^:]*:?[*_\s]*(.*)$/i;
+var COI_RE = /^[*_\s]*(conflicts? of interest|competing interests?|disclosures?|financial disclosures?|declarations? of (competing |conflicting )?interests?|conflict[- ]of[- ]interest statement)\b[^:]*:?[*_\s]*(.*)$/i;
+function declarationsFromMd(md) {
+  let coi = null;
+  const funding = [];
+  const lines = md.split("\n");
+  let section2 = "";
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i].trim();
+    const h = /^#{2,6}\s+(.*)$/.exec(l);
+    if (h) {
+      section2 = h[1];
+      const body = lines.slice(i + 1).find((x) => x.trim() && !/^#/.test(x))?.trim() ?? "";
+      if (body && /^(funding|financial support|sources? of funding|role of the funding source)/i.test(section2) && !funding.length) funding.push(body);
+      if (body && /^(conflicts? of interest|competing interests?|disclosures?|financial disclosures?|declarations? of (competing |conflicting )?interests?)/i.test(section2) && coi === null) coi = body;
+      continue;
+    }
+    if (section2 !== "Declarations" || !l) continue;
+    const f = FUNDING_RE.exec(l);
+    const c = COI_RE.exec(l);
+    if (c && c[3]?.trim() && coi === null) coi = c[3].trim().replace(/[*_]+$/, "");
+    else if (f && f[6]?.trim() && !funding.length) funding.push(f[6].trim().replace(/[*_]+$/, ""));
+  }
+  return { coi, funding };
+}
+var CORRECTED_HEADING = "## Corrected in PubMed abstract";
+function correctedSentences(r) {
+  const out = [];
+  for (const a of r.abstract) {
+    for (const s of a.text.split(/(?<=[.!?\]])\s+(?=[A-Z(\u2212-])/)) {
+      const i = s.indexOf("[corrected]");
+      if (i >= 0) out.push(s.slice(0, i).trim().replace(/\s+([.,;])$/, "$1"));
+    }
+  }
+  return out.filter(Boolean);
+}
+function withCorrectedBlock(md, sentences) {
+  const base = md.split(`
+${CORRECTED_HEADING}
+`)[0].trimEnd();
+  if (!sentences.length) return base + "\n";
+  return `${base}
+
+${CORRECTED_HEADING}
+
+NLM corrected these sentences of the abstract after an erratum; the text above may predate the correction.
+
+${sentences.join("\n\n")}
+`;
+}
+function syncCorrectedBlock(p) {
+  if (!existsSync4(p.fulltextMd) || !existsSync4(p.xml)) return;
+  let r;
+  try {
+    r = parsePubmedXml(readFileSync3(p.xml, "utf8"));
+  } catch {
+    return;
+  }
+  if (!r) return;
+  const md = readFileSync3(p.fulltextMd, "utf8");
+  const next = withCorrectedBlock(md, correctedSentences(r));
+  if (next !== md) writeAtomic(p.fulltextMd, next);
+}
+function applyFulltext(p, m, hit, converter) {
+  const raw = p.fulltextRaw(hit.format);
+  writeAtomic(raw, hit.raw);
+  writeAtomic(p.fulltextMd, hit.md);
+  syncCorrectedBlock(p);
+  const files = [...m.files.filter((f) => !f.includes("-fulltext.")), basename(raw), basename(p.fulltextMd)];
+  const own = declarationsFromMd(hit.md);
+  const next = {
+    ...m,
+    level: "full_text",
+    version: hit.version,
+    files,
+    retrieved_by: hit.tier,
+    retrieved_date: today(),
+    converted_by: converter,
+    coi: m.coi ?? own.coi,
+    funding: m.funding.length ? m.funding : own.funding
+  };
+  writeMeta(p, next);
+  return next;
+}
+function recordAttempts(p, m, labels) {
+  if (!labels.length) return m;
+  const tierOf = (a) => /^(\S+) \(/.exec(a.trim())?.[1] ?? a;
+  const replaced = new Set(labels.map(tierOf));
+  const next = { ...m, attempts: [...m.attempts.filter((a) => !replaced.has(tierOf(a))), ...labels] };
+  writeMeta(p, next);
+  return next;
+}
+function writeLabelEntry(p, s, xml, converter) {
+  mkdirSync(p.entryDir, { recursive: true });
+  const raw = p.fulltextRaw("xml");
+  writeAtomic(raw, xml);
+  writeAtomic(p.fulltextMd, renderLabelMd(s));
+  const meta = {
+    pmid: "",
+    setid: s.setid,
+    nctid: null,
+    publications: [],
+    pmcid: null,
+    doi: null,
+    title: s.title,
+    first_author: s.labeler,
+    year: s.effective?.slice(0, 4) ?? null,
+    publication_types: ["Drug Label"],
+    retracted: false,
+    corrections: [],
+    coi: null,
+    funding: [],
+    has_abstract: false,
+    level: "full_text",
+    version: s.version ? `spl ${s.version}` : null,
+    files: [basename(raw), basename(p.fulltextMd)],
+    retrieved_by: "dailymed",
+    retrieved_date: today(),
+    converted_by: converter,
+    pubmed_checked: today(),
+    attempts: []
+  };
+  writeMeta(p, meta);
+  return meta;
+}
+function writeStudyEntry(p, s, json2, converter) {
+  mkdirSync(p.entryDir, { recursive: true });
+  const raw = p.fulltextRaw("json");
+  writeAtomic(raw, json2);
+  writeAtomic(p.fulltextMd, renderStudyMd(s));
+  const meta = {
+    pmid: "",
+    setid: null,
+    nctid: s.nctid,
+    publications: s.publications,
+    pmcid: null,
+    doi: null,
+    title: s.title,
+    first_author: s.sponsor,
+    year: s.firstPosted?.slice(0, 4) ?? null,
+    publication_types: ["Trial Registration"],
+    retracted: false,
+    corrections: [],
+    coi: null,
+    funding: [],
+    has_abstract: false,
+    level: "full_text",
+    version: s.lastUpdate,
+    files: [basename(raw), basename(p.fulltextMd)],
+    retrieved_by: "ctgov",
+    retrieved_date: today(),
+    converted_by: converter,
+    pubmed_checked: today(),
+    attempts: []
+  };
+  writeMeta(p, meta);
+  return meta;
+}
+function writeDoiEntry(p, r, json2, converter, abstractFrom = "crossref", recordFrom = "crossref") {
+  mkdirSync(p.entryDir, { recursive: true });
+  const raw = p.fulltextRaw("json").replace(/-fulltext\.json$/, recordFrom === "crossref" ? "-crossref.json" : "-csl.json");
+  writeAtomic(raw, json2);
+  writeAtomic(p.md, renderAbstractMd(r));
+  const meta = { ...metaFromRecord(r, [basename(raw), basename(p.md)], converter), retrieved_by: r.abstract.length ? abstractFrom : recordFrom };
+  writeMeta(p, meta);
+  return meta;
+}
+
+// src/config.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+
+// src/checks.ts
+var GREEK = { "\u03B1": "alpha", "\u03B2": "beta", "\xDF": "beta", "\u03B3": "gamma", "\u03B4": "delta", "\u03B5": "epsilon", "\u03B6": "zeta", "\u03B7": "eta", "\u03B8": "theta", "\u03B9": "iota", "\u03BA": "kappa", "\u03BB": "lambda", "\u03BC": "mu", "\xB5": "mu", "\u03BD": "nu", "\u03BE": "xi", "\u03C0": "pi", "\u03C1": "rho", "\u03C3": "sigma", "\u03C4": "tau", "\u03C5": "upsilon", "\u03C6": "phi", "\u03C7": "chi", "\u03C8": "psi", "\u03C9": "omega", "\u0391": "alpha", "\u0392": "beta", "\u0393": "gamma", "\u0394": "delta", "\u03A9": "omega", "\u03A3": "sigma", "\u039A": "kappa", "\u039B": "lambda", "\u03A0": "pi", "\u03A6": "phi", "\u03A8": "psi" };
+var greek = (s) => s.replace(/[\u0370-\u03ff\u00b5\u00df]/g, (c) => GREEK[c] ?? c);
+var norm = (s) => greek(s).toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+var compact = (s) => greek(s).toLowerCase().replace(/[^a-z0-9]+/g, "");
+function hasTitle(md, title) {
+  const t = norm(title);
+  if (!t) return true;
+  if (norm(md).includes(t.slice(0, 60))) return true;
+  return compact(md).includes(compact(title).slice(0, 50));
+}
+var WALL = [
+  /checking your browser/i,
+  /recaptcha/i,
+  /verify (that )?you are (a )?human/i,
+  /human verification/i,
+  /access denied/i,
+  /enable javascript/i,
+  /javascript is (disabled|required)/i,
+  /cloudflare/i,
+  /captcha/i,
+  /sign in to (continue|access)/i,
+  /purchase (access|this article|pdf)/i,
+  /subscribe to (read|access)/i,
+  /cookie.{0,40}(consent|wall)/i,
+  /403 forbidden/i,
+  /page not found/i
+];
+function isWallPage(text3) {
+  const short = text3.length < 4e3;
+  if (short && WALL.some((re) => re.test(text3))) return true;
+  const title = /<title>([^<]*)<\/title>/i.exec(text3)?.[1] ?? "";
+  return /checking your browser|recaptcha|just a moment|access denied|attention required|human verification/i.test(title);
+}
+var headings = (md) => md.split("\n").filter((l) => /^#{1,6}\s/.test(l)).map((l) => l.replace(/^#+\s*/, ""));
+function proseWords(md) {
+  let n = 0;
+  for (const p of md.split(/\n\s*\n/).map((x) => x.trim()).filter((x) => x && !/^#{1,6}\s/.test(x))) {
+    const words2 = p.split(/\s+/).length;
+    if (words2 < 40 || /^(-|\*|\d+\.)\s/.test(p)) continue;
+    const linkChars = (p.match(/\[[^\]]*\]\([^)]*\)/g) ?? []).join("").length;
+    if (linkChars / p.length > 0.3) continue;
+    n += words2;
+  }
+  return n;
+}
+var MIN_PROSE = 800;
+function hasMethodsAndResults(md) {
+  const hs = headings(md);
+  const has = (re) => hs.some((h) => re.test(h));
+  if (has(/method|material|procedure|design|experimental|patients? and|participants/i) && has(/result|finding|outcome/i)) return true;
+  const words2 = md.split(/\s+/).length;
+  if (words2 < 1200 || hs.length < 2) return false;
+  const SECTION = /^(abstract|summary|introduction|background|discussion|conclusions?|references|acknowledg|limitations|key points|funding|participants|statistical|supplementary|data availability|author contributions|competing interests|conflicts? of interest|disclosure)/i;
+  return hs.filter((h) => SECTION.test(h.trim())).length >= 2;
+}
+var hasDoi = (md, doi) => !!doi && compact(md).includes(compact(doi));
+function checkFulltext(md, title, titleSource, doi, trusted = false) {
+  if (isWallPage(md)) return { ok: false, reason: "wall page" };
+  const inBody = hasTitle(md, title);
+  if (!inBody && !(titleSource && hasTitle(titleSource, title)) && !hasDoi(md, doi)) return { ok: false, reason: "title missing" };
+  if (!trusted && proseWords(md) < MIN_PROSE) return { ok: false, reason: "no methods/results" };
+  if (!hasMethodsAndResults(md)) return { ok: false, reason: "no methods/results" };
+  return { ok: true };
+}
+
+// src/html.ts
+import TurndownService from "turndown";
+import { gfm } from "@joplin/turndown-plugin-gfm";
+var td = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced", bulletListMarker: "-" });
+td.use(gfm);
+td.remove(["script", "style", "nav", "noscript", "iframe", "button", "input", "select", "textarea", "header", "footer", "aside"]);
+var FURNITURE = /gdpr|cookie|onetrust|consent|advert|\bad-slot\b/i;
+td.remove(((n) => ["div", "section"].includes(String(n.nodeName).toLowerCase()) && FURNITURE.test(`${n.className ?? ""} ${n.id ?? ""}`)));
+td.addRule("drop-svg", { filter: (n) => n.nodeName.toLowerCase() === "svg", replacement: () => "" });
+td.addRule("drop-images", { filter: ["img"], replacement: () => "" });
+td.addRule("div-headings", {
+  filter: (n) => String(n.nodeName).toLowerCase() === "div" && /(^|\s)h[1-6](\s|$)/.test(String(n.className ?? "")),
+  replacement: (content, n) => {
+    const level = /(^|\s)h([1-6])(\s|$)/.exec(String(n.className))[2];
+    return `
+
+${"#".repeat(Number(level))} ${content.trim()}
+
+`;
+  }
+});
+function htmlToMarkdown(html) {
+  return td.turndown(html).replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+
+// src/jats.ts
+import { XMLParser as XMLParser3 } from "fast-xml-parser";
+var parser3 = new XMLParser3({
+  preserveOrder: true,
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  parseTagValue: false,
+  trimValues: false,
+  processEntities: true,
+  htmlEntities: true
+});
+var tagOf2 = (n) => Object.keys(n).find((k) => k !== ":@") ?? "";
+var kids2 = (n) => n[tagOf2(n)] ?? [];
+var attr2 = (n, a) => n[":@"]?.[`@_${a}`] ?? "";
+var SKIP_INLINE = /* @__PURE__ */ new Set(["inline-graphic", "graphic", "private-char"]);
+function formula(n) {
+  const all = [n, ...descendants(n)];
+  const tex = all.find((x) => tagOf2(x) === "tex-math");
+  if (tex) {
+    let t = plainText(kids2(tex)).trim();
+    const m = /\\begin\{document\}([\s\S]*?)\\end\{document\}/.exec(t);
+    if (m) t = m[1].trim();
+    t = t.replace(/^\$+|\$+$/g, "").trim();
+    return t ? `$${t}$` : "";
+  }
+  const mml = all.find((x) => /^(mml:)?math$/.test(tagOf2(x)));
+  return mml ? plainText(kids2(mml)).replace(/\s+/g, "") : plainText(kids2(n));
+}
+function descendants(n) {
+  if ("#text" in n) return [];
+  const out = [];
+  for (const k of kids2(n)) {
+    out.push(k, ...descendants(k));
+  }
+  return out;
+}
+function inlineText2(nodes) {
+  let out = "";
+  for (const n of nodes) {
+    if ("#text" in n) {
+      out += String(n["#text"]);
+      continue;
+    }
+    const t = tagOf2(n);
+    if (SKIP_INLINE.has(t)) continue;
+    const inner = () => inlineText2(kids2(n));
+    switch (t) {
+      case "italic":
+      case "i":
+        out += `*${inner()}*`;
+        break;
+      case "bold":
+      case "b":
+        out += `**${inner()}**`;
+        break;
+      case "sup":
+        out += `^${inner()}^`;
+        break;
+      case "sub":
+        out += `~${inner()}~`;
+        break;
+      case "break":
+        out += " ";
+        break;
+      case "ext-link":
+      case "uri": {
+        const href = attr2(n, "xlink:href") || attr2(n, "href");
+        const text3 = inner().trim() || href;
+        out += href ? `[${text3}](${href})` : text3;
+        break;
+      }
+      case "inline-formula":
+      case "tex-math":
+      case "mml:math":
+      case "alternatives":
+        out += formula(n);
+        break;
+      default:
+        out += inner();
+    }
+  }
+  return out;
+}
+function plainText(nodes) {
+  let out = "";
+  for (const n of nodes) out += "#text" in n ? String(n["#text"]) : plainText(kids2(n));
+  return out;
+}
+var squash2 = (s) => s.replace(/\s+/g, " ").trim();
+var cell = (s) => squash2(s).replace(/\|/g, "\\|");
+function renderTable(table3) {
+  const rows = [];
+  const walk = (nodes) => {
+    for (const n of nodes) {
+      const t = tagOf2(n);
+      if (t === "tr") rows.push(kids2(n).filter((c) => ["td", "th"].includes(tagOf2(c))).map((c) => cell(inlineText2(kids2(c)))));
+      else if (!("#text" in n)) walk(kids2(n));
+    }
+  };
+  walk(kids2(table3));
+  if (!rows.length) return "";
+  const width = Math.max(...rows.map((r) => r.length));
+  const pad = (r) => [...r, ...Array(width - r.length).fill("")];
+  const line = (r) => `| ${pad(r).join(" | ")} |`;
+  return [line(rows[0]), `| ${Array(width).fill("---").join(" | ")} |`, ...rows.slice(1).map(line)].join("\n");
+}
+function labelCaption(n) {
+  const label = n ? squash2(plainText(kids2(n).filter((c) => tagOf2(c) === "label"))) : "";
+  const cap = kids2(n).find((c) => tagOf2(c) === "caption");
+  const capText = cap ? squash2(inlineText2(kids2(cap))) : "";
+  return [label ? `**${label}.**` : "", capText].filter(Boolean).join(" ");
+}
+function renderBlocks(nodes, depth) {
+  const out = [];
+  for (const n of nodes) {
+    if ("#text" in n) {
+      const t2 = squash2(String(n["#text"]));
+      if (t2) out.push(t2);
+      continue;
+    }
+    const t = tagOf2(n);
+    const c = kids2(n);
+    switch (t) {
+      case "sec":
+      case "app":
+      case "ack":
+      case "boxed-text":
+      case "notes":
+      case "glossary": {
+        const title = c.find((x) => tagOf2(x) === "title");
+        if (title) out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${squash2(inlineText2(kids2(title)))}`);
+        else if (t === "ack") out.push(`${"#".repeat(Math.min(depth + 1, 6))} Acknowledgements`);
+        out.push(...renderBlocks(c.filter((x) => tagOf2(x) !== "title"), depth + 1));
+        break;
+      }
+      case "title":
+        out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${squash2(inlineText2(c))}`);
+        break;
+      case "p": {
+        const BLOCK = /* @__PURE__ */ new Set(["table-wrap", "fig", "list", "disp-formula", "disp-quote", "boxed-text", "supplementary-material"]);
+        const inline2 = c.filter((x) => "#text" in x || !BLOCK.has(tagOf2(x)));
+        const blocks2 = c.filter((x) => !("#text" in x) && BLOCK.has(tagOf2(x)));
+        const s = squash2(inlineText2(inline2));
+        if (s) out.push(s);
+        out.push(...renderBlocks(blocks2, depth));
+        break;
+      }
+      case "list": {
+        const ordered = /order|alpha|roman|number/i.test(attr2(n, "list-type"));
+        let i = 0;
+        for (const li of c.filter((x) => tagOf2(x) === "list-item")) {
+          i++;
+          const body = renderBlocks(kids2(li).filter((x) => tagOf2(x) !== "label"), depth).join(" ");
+          out.push(`${ordered ? `${i}.` : "-"} ${body}`);
+        }
+        break;
+      }
+      case "table-wrap": {
+        const head = labelCaption(n);
+        if (head) out.push(head);
+        for (const tbl of c.filter((x) => tagOf2(x) === "table")) {
+          const md = renderTable(tbl);
+          if (md) out.push(md);
+        }
+        const foot = c.find((x) => tagOf2(x) === "table-wrap-foot");
+        if (foot) out.push(...renderBlocks(kids2(foot), depth));
+        break;
+      }
+      case "fig": {
+        const head = labelCaption(n);
+        out.push(head || "*(figure)*");
+        break;
+      }
+      case "disp-formula": {
+        const s = squash2(formula(n));
+        if (s) out.push(s);
+        break;
+      }
+      case "disp-quote":
+        out.push(...renderBlocks(c, depth).map((l) => `> ${l}`));
+        break;
+      case "def-list":
+        for (const d of c.filter((x) => tagOf2(x) === "def-item")) {
+          const term = d["def-item"].find((x) => tagOf2(x) === "term");
+          const def = d["def-item"].find((x) => tagOf2(x) === "def");
+          out.push(`**${squash2(inlineText2(term ? kids2(term) : []))}**: ${def ? renderBlocks(kids2(def), depth).join(" ") : ""}`);
+        }
+        break;
+      case "ref-list": {
+        const title = c.find((x) => tagOf2(x) === "title");
+        out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${title ? squash2(inlineText2(kids2(title))) : "References"}`);
+        for (const r of c.filter((x) => tagOf2(x) === "ref")) {
+          const rk = kids2(r);
+          const label = squash2(plainText(rk.filter((x) => tagOf2(x) === "label")));
+          out.push(`- ${label ? `${label} ` : ""}${renderCitation(rk.filter((x) => tagOf2(x) !== "label"))}`);
+        }
+        break;
+      }
+      case "supplementary-material":
+      case "graphic":
+      case "media":
+      case "fn-group":
+      case "label":
+        break;
+      default:
+        out.push(...renderBlocks(c, depth));
+    }
+  }
+  return out;
+}
+function renderCitation(nodes) {
+  const alt = nodes.find((x) => tagOf2(x) === "citation-alternatives");
+  if (alt) return renderCitation(kids2(alt));
+  const mixed = nodes.find((x) => ["mixed-citation", "citation", "nlm-citation"].includes(tagOf2(x)) && !kids2(x).some((y) => tagOf2(y) === "person-group"));
+  if (mixed) return squash2(inlineText2(kids2(mixed)));
+  const el = nodes.find((x) => ["element-citation", "mixed-citation", "citation", "nlm-citation"].includes(tagOf2(x)));
+  if (!el) return squash2(inlineText2(nodes));
+  const f = kids2(el);
+  const get = (tag) => f.filter((x) => tagOf2(x) === tag).map((x) => squash2(inlineText2(kids2(x))));
+  const names = f.filter((x) => tagOf2(x) === "person-group").flatMap((g) => kids2(g)).map((x) => {
+    const t = tagOf2(x);
+    if (t === "etal") return "et al";
+    if (t === "collab") return squash2(plainText(kids2(x)));
+    if (t === "name" || t === "string-name") {
+      const sur = squash2(plainText(kids2(x).filter((y) => tagOf2(y) === "surname")));
+      const giv = squash2(plainText(kids2(x).filter((y) => tagOf2(y) === "given-names")));
+      return [sur, giv].filter(Boolean).join(" ");
+    }
+    return "";
+  }).filter(Boolean);
+  const vol = get("volume")[0], issue = get("issue")[0], fp = get("fpage")[0], lp = get("lpage")[0];
+  const pages = fp ? lp ? `${fp}-${lp}` : fp : get("elocation-id")[0];
+  const where = [get("source")[0], get("year")[0] ? `${get("year")[0]};` : "", vol ? `${vol}${issue ? `(${issue})` : ""}` : "", pages ? `:${pages}` : ""].filter(Boolean).join("").replace(/;$/, "");
+  const ids = f.filter((x) => tagOf2(x) === "pub-id").map((x) => `${attr2(x, "pub-id-type")}:${squash2(plainText(kids2(x)))}`);
+  return [names.join(", "), [...get("article-title"), ...get("chapter-title")][0], where, ...ids].filter(Boolean).join(". ").replace(/\.\./g, ".");
+}
+var FN_LABELS = {
+  "conflict": "Conflicts of interest",
+  "COI-statement": "Conflicts of interest",
+  "coi-statement": "Conflicts of interest",
+  "financial-disclosure": "Financial disclosure",
+  "supported-by": "Funding",
+  "funding": "Funding",
+  "equal": "Author note",
+  "con": "Contributions",
+  "contributed-by": "Contributions",
+  "other": ""
+};
+function declarations(meta, back) {
+  const out = [];
+  const fg = meta ? findDeep2(kids2(meta), "funding-group") : void 0;
+  if (fg) {
+    const statements = kids2(fg).filter((x) => tagOf2(x) === "funding-statement").map((x) => squash2(inlineText2(kids2(x)))).filter(Boolean);
+    const awards = kids2(fg).filter((x) => tagOf2(x) === "award-group").map((ag) => {
+      const src = kids2(ag).filter((x) => tagOf2(x) === "funding-source").map((x) => squash2(plainText(kids2(x)))).filter(Boolean);
+      const ids = kids2(ag).filter((x) => tagOf2(x) === "award-id").map((x) => squash2(plainText(kids2(x)))).filter(Boolean);
+      return [src.join(", "), ids.length ? `(${ids.join(", ")})` : ""].filter(Boolean).join(" ");
+    }).filter(Boolean);
+    const text3 = statements.length ? statements.join(" ") : awards.join("; ");
+    if (text3) out.push(`Funding: ${text3}`);
+  }
+  const fns = [];
+  const notes = meta ? findDeep2(kids2(meta), "author-notes") : void 0;
+  if (notes) fns.push(...kids2(notes).filter((x) => tagOf2(x) === "fn"));
+  if (back) for (const g of kids2(back).filter((x) => tagOf2(x) === "fn-group")) fns.push(...kids2(g).filter((x) => tagOf2(x) === "fn"));
+  for (const fn of fns) {
+    const text3 = renderBlocks(kids2(fn).filter((x) => tagOf2(x) !== "label"), 1).join(" ").trim();
+    if (!text3) continue;
+    const label = FN_LABELS[attr2(fn, "fn-type")] ?? "";
+    out.push(label && !new RegExp(`^[*_]*${label.split(" ")[0]}`, "i").test(text3) ? `${label}: ${text3}` : text3);
+  }
+  return out;
+}
+function find(nodes, path) {
+  let cur = nodes;
+  let hit;
+  for (const tag of path) {
+    hit = cur.find((x) => tagOf2(x) === tag);
+    if (!hit) return void 0;
+    cur = kids2(hit);
+  }
+  return hit;
+}
+function findDeep2(nodes, tag) {
+  for (const n of nodes) {
+    if ("#text" in n) continue;
+    if (tagOf2(n) === tag) return n;
+    const hit = findDeep2(kids2(n), tag);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function parseJats(xml) {
+  const doc = parser3.parse(xml);
+  const article = find(doc, ["pmc-articleset", "article"]) ?? find(doc, ["article"]) ?? findDeep2(doc, "article");
+  const a = article ? kids2(article) : [];
+  const front = find(a, ["front"]);
+  const meta = front ? find(kids2(front), ["article-meta"]) ?? front : void 0;
+  const titleNode = meta ? find(kids2(meta), ["title-group", "article-title"]) ?? findDeep2(kids2(meta), "article-title") : void 0;
+  const abstractNode = meta ? kids2(meta).find((x) => tagOf2(x) === "abstract" && !attr2(x, "abstract-type")) ?? findDeep2(kids2(meta), "abstract") : void 0;
+  const body = find(a, ["body"]);
+  const back = find(a, ["back"]);
+  return {
+    title: titleNode ? squash2(inlineText2(kids2(titleNode))) : "",
+    abstract: abstractNode ? renderBlocks(kids2(abstractNode).filter((x) => tagOf2(x) !== "title"), 2) : [],
+    body: body ? renderBlocks(kids2(body), 1) : [],
+    declarations: declarations(meta, back),
+    back: back ? renderBlocks(kids2(back), 1) : [],
+    hasBody: !!body && kids2(body).length > 0
+  };
+}
+function renderFulltextMd(doc, headLine2) {
+  const parts = [`# ${doc.title}`, "", headLine2, ""];
+  if (doc.abstract.length) parts.push("## Abstract", "", ...doc.abstract.flatMap((b) => [b, ""]));
+  parts.push(...doc.body.flatMap((b) => [b, ""]));
+  if (doc.declarations.length) parts.push("## Declarations", "", ...doc.declarations.flatMap((b) => [b, ""]));
+  parts.push(...doc.back.flatMap((b) => [b, ""]));
+  return parts.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+// src/browser.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { chromium } from "playwright-core";
+function browserConfig(file = CONFIG_FILE) {
+  const out = { browsers: [], headless: "auto" };
+  if (!existsSync5(file)) return out;
+  try {
+    const d = JSON.parse(readFileSync4(file, "utf8")).download ?? {};
+    if (Array.isArray(d.browsers)) {
+      for (const b of d.browsers) {
+        if (typeof b !== "string") continue;
+        const v = resolveEnv(b).trim();
+        if (v && !/^\$\{[A-Z0-9_]+\}$/.test(v) && !out.browsers.includes(v)) out.browsers.push(v);
+      }
+    }
+    if (d.headless === "auto" || typeof d.headless === "boolean") out.headless = d.headless;
+  } catch {
+  }
+  return out;
+}
+var INSTALL_HINT = "npx playwright-core install chromium";
+var isRemote = (endpoint) => /^wss?:\/\//i.test(endpoint);
+var isCdp = (endpoint) => /^cdp:\/\//i.test(endpoint);
+var cdpHttp = (endpoint) => endpoint.replace(/^cdp:\/\//i, "http://");
+var rungKind = (endpoint) => isCdp(endpoint) ? "chrome" : isRemote(endpoint) ? "server" : "local";
+function localChromium() {
+  try {
+    const p = chromium.executablePath();
+    return existsSync5(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+function browserLabel(endpoint) {
+  if (rungKind(endpoint) === "local") return "local";
+  try {
+    const h = new URL(isCdp(endpoint) ? cdpHttp(endpoint) : endpoint).hostname;
+    return isCdp(endpoint) ? `chrome@${h}` : h;
+  } catch {
+    return endpoint;
+  }
+}
+var hasDisplay = () => !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+function browserHeadless(endpoint, cfg = browserConfig()) {
+  if (isCdp(endpoint)) return false;
+  return cfg.headless === "auto" ? isRemote(endpoint) ? false : !hasDisplay() : cfg.headless;
+}
+function browserRungs(cfg = browserConfig()) {
+  return cfg.browsers.map((endpoint) => ({
+    endpoint,
+    label: browserLabel(endpoint),
+    kind: rungKind(endpoint),
+    available: rungKind(endpoint) !== "local" || localChromium() !== null,
+    headless: browserHeadless(endpoint, cfg)
+  }));
+}
+var CHALLENGE = /just a moment|nur einen moment|attention required|verify you are human|human verification|checking your browser|access denied/i;
+var CONNECT_TIMEOUT_MS = 2e4;
+var NAV_TIMEOUT_MS = 2e4;
+var CHALLENGE_WAIT_MS = 8e3;
+var DOWNLOAD_WAIT_MS = 1e4;
+var IDLE_CLOSE_MS = 12e4;
+var ctxs = /* @__PURE__ */ new Map();
+var idleTimer = null;
+function profileDir() {
+  const dir = join5(AI4L_LIBRARY_DIR, ".browser");
+  mkdirSync2(join5(dir, "Default"), { recursive: true });
+  const prefs = join5(dir, "Default", "Preferences");
+  let p = {};
+  try {
+    p = JSON.parse(readFileSync4(prefs, "utf8"));
+  } catch {
+  }
+  p.plugins = { ...p.plugins ?? {}, always_open_pdf_externally: true };
+  p.download = { ...p.download ?? {}, prompt_for_download: false };
+  writeFileSync2(prefs, JSON.stringify(p));
+  return dir;
+}
+var LAUNCH_ARGS = ["--disable-blink-features=AutomationControlled", "--window-size=1366,900"];
+var LOCAL_WINDOW_ARGS = [...LAUNCH_ARGS, "--window-position=4000,4000"];
+var TIMEZONE = Intl.DateTimeFormat().resolvedOptions().timeZone || "Europe/Berlin";
+var CONTEXT_OPTS = { acceptDownloads: true, viewport: null, locale: "en-US", timezoneId: TIMEZONE };
+function stateFile(endpoint) {
+  const dir = join5(AI4L_LIBRARY_DIR, ".browser");
+  mkdirSync2(dir, { recursive: true });
+  return join5(dir, `${browserLabel(endpoint).replace(/[^A-Za-z0-9.-]+/g, "_")}.json`);
+}
+async function context(endpoint, cfg) {
+  let p = ctxs.get(endpoint);
+  if (!p) {
+    p = (async () => {
+      const headless = browserHeadless(endpoint, cfg);
+      const drop = () => {
+        if (ctxs.get(endpoint) === p) ctxs.delete(endpoint);
+      };
+      if (isCdp(endpoint)) {
+        const browser = await chromium.connectOverCDP(cdpHttp(endpoint), { timeout: CONNECT_TIMEOUT_MS });
+        browser.on("disconnected", drop);
+        const ctx2 = browser.contexts()[0] ?? await browser.newContext(CONTEXT_OPTS);
+        return { ctx: ctx2, browser };
+      }
+      if (isRemote(endpoint)) {
+        const browser = await chromium.connect(endpoint, {
+          timeout: CONNECT_TIMEOUT_MS,
+          headers: { "x-playwright-launch-options": JSON.stringify({ headless, args: LAUNCH_ARGS, ignoreDefaultArgs: ["--enable-automation"] }) }
+        });
+        browser.on("disconnected", drop);
+        const state = stateFile(endpoint);
+        const ctx2 = await browser.newContext({ ...CONTEXT_OPTS, ...existsSync5(state) ? { storageState: state } : {} });
+        return { ctx: ctx2, browser };
+      }
+      if (!localChromium()) throw new Error(`no local Chromium (${INSTALL_HINT})`);
+      const ctx = await chromium.launchPersistentContext(profileDir(), {
+        channel: "chromium",
+        headless,
+        ...CONTEXT_OPTS,
+        args: headless ? LAUNCH_ARGS : LOCAL_WINDOW_ARGS,
+        ignoreDefaultArgs: ["--enable-automation"]
+      });
+      ctx.on("close", drop);
+      return { ctx, browser: null };
+    })();
+    ctxs.set(endpoint, p);
+    p.catch(() => {
+      if (ctxs.get(endpoint) === p) ctxs.delete(endpoint);
+    });
+  }
+  return (await p).ctx;
+}
+function touchIdle() {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(() => {
+    void closeBrowsers();
+  }, IDLE_CLOSE_MS);
+  idleTimer.unref();
+}
+async function closeBrowsers() {
+  const open = [...ctxs.entries()];
+  ctxs.clear();
+  for (const [endpoint, p] of open) {
+    try {
+      const { ctx, browser } = await p;
+      if (isCdp(endpoint)) {
+        await browser?.close().catch(() => void 0);
+        continue;
+      }
+      if (browser) await ctx.storageState({ path: stateFile(endpoint) }).catch(() => void 0);
+      await ctx.close().catch(() => void 0);
+      await browser?.close().catch(() => void 0);
+    } catch {
+    }
+  }
+}
+async function browserFetch(url, endpoint, cfg = browserConfig()) {
+  const ctx = await context(endpoint, cfg);
+  touchIdle();
+  const page = await ctx.newPage();
+  try {
+    let pdfBest = null;
+    const pdfReads = [];
+    let status, contentType = "";
+    page.on("response", (r) => {
+      if (r.request().isNavigationRequest() && r.frame() === page.mainFrame()) {
+        status = r.status();
+        contentType = r.headers()["content-type"] ?? "";
+      }
+      if (r.status() !== 200 || !/application\/pdf/i.test(r.headers()["content-type"] ?? "")) return;
+      pdfReads.push(r.body().then((b) => {
+        if (b.subarray(0, 5).toString("latin1") === "%PDF-" && (!pdfBest || b.length > pdfBest.length)) pdfBest = b;
+      }).catch(() => void 0));
+    });
+    let download2 = null;
+    const dl = page.waitForEvent("download", { timeout: NAV_TIMEOUT_MS + CHALLENGE_WAIT_MS + DOWNLOAD_WAIT_MS }).then((d) => {
+      download2 = d;
+      return d;
+    }).catch(() => null);
+    let navError = null;
+    const nav = page.goto(url, { waitUntil: "domcontentloaded", timeout: NAV_TIMEOUT_MS }).then((resp) => {
+      if (status === void 0) {
+        status = resp?.status();
+        contentType = resp?.headers()["content-type"] ?? "";
+      }
+    }).catch((e) => {
+      navError = (e instanceof Error ? e.message : String(e)).split("\n")[0].slice(0, 80);
+    });
+    await Promise.race([nav, dl]);
+    const pause = (ms) => Promise.race([dl, new Promise((r) => setTimeout(r, ms))]);
+    if (download2) {
+    } else if (navError && !/download is starting|net::ERR_ABORTED/i.test(navError)) {
+      await pause(2e3);
+      if (!download2) throw new Error(`navigation: ${navError}`);
+    } else {
+      await pause(2e3);
+      const t0 = Date.now();
+      while (!download2 && Date.now() - t0 < CHALLENGE_WAIT_MS) {
+        const title2 = await page.title().catch(() => "");
+        if (!CHALLENGE.test(title2)) break;
+        await pause(1e3);
+      }
+      if (!download2) await pause(DOWNLOAD_WAIT_MS / 5);
+    }
+    if (download2) {
+      const d = download2;
+      return { bytes: readFileSync4(await d.path()), contentType: "application/pdf", url: d.url(), via: "download" };
+    }
+    const title = await page.title().catch(() => "");
+    if (CHALLENGE.test(title)) throw new Error(`challenge not cleared (${title.slice(0, 40)})`);
+    if (status && status >= 400) throw new Error(`HTTP ${status}`);
+    const docType = await page.evaluate(() => document.contentType).catch(() => "");
+    const inViewer = /application\/pdf/i.test(contentType) || /application\/pdf/i.test(docType);
+    if (inViewer) {
+      const t1 = Date.now();
+      while (Date.now() - t1 < DOWNLOAD_WAIT_MS) {
+        await Promise.all(pdfReads);
+        if (pdfBest && pdfBest.length > 4096) break;
+        if (!pdfReads.length && Date.now() - t1 > 3e3) break;
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      if (pdfBest) return { bytes: pdfBest, contentType: "application/pdf", url: page.url(), via: "response" };
+    }
+    if (inViewer) {
+      const r = await ctx.request.get(page.url(), { timeout: NAV_TIMEOUT_MS });
+      if (!r.ok()) throw new Error(`HTTP ${r.status()} (pdf request)`);
+      return { bytes: Buffer.from(await r.body()), contentType: "application/pdf", url: page.url(), via: "request" };
+    }
+    const html = await page.content();
+    return { bytes: Buffer.from(html, "utf8"), contentType: contentType || "text/html", url: page.url(), via: "page" };
+  } finally {
+    await page.close().catch(() => void 0);
+    if (isRemote(endpoint)) await ctx.storageState({ path: stateFile(endpoint) }).catch(() => void 0);
+  }
+}
+
+// src/unlock.ts
+var ENDPOINT = "https://api.brightdata.com/request";
+var TIMEOUT_MS2 = 6e4;
+var unlockerConfigured = () => !!process.env.BRIGHTDATA_API_TOKEN?.trim();
+async function unlock(url, fetchImpl = fetch) {
+  const token = process.env.BRIGHTDATA_API_TOKEN?.trim();
+  if (!token) throw new Error("unlocker not configured");
+  const zone = process.env.BRIGHTDATA_ZONE?.trim() || "mcp_unlocker";
+  const res = await fetchImpl(ENDPOINT, {
+    method: "POST",
+    headers: { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ zone, url, format: "raw" }),
+    signal: AbortSignal.timeout(TIMEOUT_MS2)
+  });
+  if (!res.ok) throw new Error(`unlocker HTTP ${res.status}`);
+  return { bytes: Buffer.from(await res.arrayBuffer()), contentType: res.headers.get("content-type") ?? "" };
+}
+
+// src/tiers/tier.ts
+function oaVersion(v) {
+  if (v === "acceptedVersion") return "accepted_manuscript";
+  if (v === "submittedVersion") return "preprint";
+  return "published";
+}
+var miss = (tier, reason) => ({ ok: false, tier, reason });
+var errMsg = (e) => (e instanceof Error ? e.message : String(e)).replace(/\x1b\[[0-9;]*m/g, "").split("\n")[0].trim().slice(0, 200);
+
+// src/download.ts
+var hostOf = (url) => {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+};
+var NCBI = /^https?:\/\/([a-z0-9.-]+\.)?(ncbi\.nlm\.nih\.gov|pubmed\.gov)\//i;
+function order(candidates) {
+  const rank = (c) => (c.pdf ? 0 : 2) + (c.host === "publisher" ? 1 : 0);
+  return [...candidates].sort((a, b) => rank(a) - rank(b));
+}
+async function download(tier, p, candidates, ctx) {
+  const usable = candidates.filter((c) => !NCBI.test(c.url));
+  if (!usable.length && candidates.length) return miss(tier, "only pmc copies (covered by the pmc tier)");
+  const ordered = order(usable).filter((c) => !ctx.tried.has(c.url));
+  if (!ordered.length) return miss(tier, "only copies already tried");
+  const reasons = [];
+  for (const c of ordered) {
+    ctx.tried.add(c.url);
+    let r = await tryOne(p, c, tier);
+    const target = !r.ok && r.url && r.url !== c.url ? { ...c, url: r.url } : c;
+    if (target !== c) ctx.onTry?.(`${c.url} \u2192 ${target.url}`);
+    ctx.onTry?.(r.ok ? `${target.url} ok fetch` : `${target.url} failed fetch: ${r.reason}`);
+    const why = (reason) => reason.replace(/^not a pdf \((.*)\)$/, "$1");
+    for (const b of browserRungs()) {
+      if (r.ok || c.headers || c.service || !b.available || !/^(HTTP 403|HTTP 429|wall page|no methods\/results|unknown content|browser )/.test(why(r.reason))) break;
+      r = await tryOne(p, target, tier, { browser: b.endpoint, label: b.label });
+      ctx.onTry?.(r.ok ? `${target.url} ok browser ${b.label}` : `${target.url} failed browser ${b.label}: ${bare(r.reason)}`);
+    }
+    if (!r.ok && !c.headers && !c.service && unlockerConfigured() && /^(HTTP 403|wall page|browser )/.test(why(r.reason))) {
+      r = await tryOne(p, target, tier, "unlocker");
+      ctx.onTry?.(r.ok ? `${target.url} ok brightdata` : `${target.url} failed brightdata: ${bare(r.reason)}`);
+    }
+    if (r.ok) return r;
+    reasons.push(`${r.reason}: ${hostOf(c.url)}`);
+  }
+  return miss(tier, reasons.join("; "));
+}
+var bare = (reason) => reason.replace(/^(brightdata|browser [^:]+): /, "");
+async function tryOne(p, c, tier, via = "plain") {
+  let got;
+  try {
+    got = via === "unlocker" ? await unlock(c.url) : typeof via === "object" ? await browserFetch(c.url, via.browser) : await fetchBytes(c.url, { ...DOWNLOAD_HEADERS, ...c.headers ?? {} });
+  } catch (e) {
+    const body = e?.body;
+    if (c.service && body?.trim()) return { ok: false, reason: `${errMsg(e)} \u2014 ${serviceMessage(Buffer.from(body), e.contentType)}`, url: e?.url };
+    return { ok: false, reason: (via === "plain" ? "" : via === "unlocker" ? "brightdata: " : `browser ${via.label}: `) + errMsg(e), url: e?.url };
+  }
+  const { bytes, contentType } = got;
+  if (c.service && !looksLikePdf(bytes) && !isXmlArticle(bytes.toString("utf8"))) return { ok: false, reason: `service: ${serviceMessage(bytes, contentType)}`, url: got.url };
+  if (via === "unlocker" && !bytes.length) return { ok: false, reason: "brightdata: empty response" };
+  const r = await convertBytes(p, bytes, contentType);
+  if (!r.ok) return { ok: false, reason: c.pdf && r.format !== "pdf" ? `not a pdf (${r.reason})` : r.reason, url: got.url };
+  return { ok: true, tier, format: r.format, raw: r.format === "pdf" ? bytes : bytes.toString("utf8"), md: r.md, version: c.version };
+}
+var isXmlArticle = (text3) => /^\s*<\?xml|<article\b/.test(text3.slice(0, 2e3)) && !/<html/i.test(text3.slice(0, 2e3));
+function serviceMessage(bytes, contentType = "") {
+  const text3 = bytes.toString("utf8").trim();
+  if (!text3) return `empty response (${contentType.split(";")[0] || "no type"})`;
+  try {
+    const j = JSON.parse(text3);
+    const m = j?.message ?? j?.error?.message ?? j?.error ?? j?.detail;
+    if (typeof m === "string" && m.trim()) return m.trim().replace(/\s+/g, " ").slice(0, 160);
+  } catch {
+  }
+  const visible = text3.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>/gi, " ").replace(/<title>([\s\S]*?)<\/title>/i, "$1. ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+  return (visible || text3).slice(0, 160);
+}
+function describe(reason, format, md) {
+  const words2 = md.split(/\s+/).filter(Boolean).length;
+  const headings2 = md.split("\n").filter((l) => /^#{2,6}\s/.test(l)).length;
+  const seen = `${format}, ${words2} words, ${proseWords(md)} in prose, ${headings2} heading${headings2 === 1 ? "" : "s"}`;
+  if (reason === "no methods/results") return `no article body (${seen})`;
+  if (reason === "title missing") return `neither title nor DOI in text (${seen})`;
+  return reason;
+}
+async function convertBytes(p, bytes, contentType = "") {
+  let format;
+  let md;
+  if (looksLikePdf(bytes)) {
+    format = "pdf";
+    const stats = {};
+    try {
+      md = await pdfToMarkdown(bytes, p.title, p.headLine, stats);
+    } catch (e) {
+      return { ok: false, reason: `pdf: ${errMsg(e)}` };
+    }
+    if ((stats.pages ?? 0) >= 1 && (stats.chars ?? 0) < 500 * (stats.pages ?? 1)) return { ok: false, reason: "scanned pdf", format };
+  } else {
+    const text3 = bytes.toString("utf8");
+    if (isWallPage(text3)) return { ok: false, reason: "wall page" };
+    if (/^\s*<\?xml|<article\b/.test(text3.slice(0, 2e3)) && /<body\b/.test(text3) && !/<html/i.test(text3.slice(0, 2e3))) {
+      format = "xml";
+      const doc = parseJats(/full-text-retrieval-response/.test(text3.slice(0, 3e3)) ? elsevierToJats(text3) : text3);
+      if (!doc.title) doc.title = p.title;
+      if (!doc.hasBody) return { ok: false, reason: "xml without body" };
+      md = renderFulltextMd(doc, p.headLine);
+    } else if (/text\/html|<html/i.test(contentType + text3.slice(0, 500))) {
+      format = "html";
+      const body = /<body[^>]*>([\s\S]*)<\/body>/i.exec(text3)?.[1] ?? text3;
+      md = `# ${p.title}
+
+${p.headLine}
+
+${htmlToMarkdown(body)}`;
+    } else {
+      return { ok: false, reason: `unknown content (${contentType.split(";")[0] || "no type"})` };
+    }
+  }
+  const content = format === "xml" ? md : md.replace(/^# [^\n]*\n/, "");
+  const rawText = format === "html" ? bytes.toString("utf8").replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ") : void 0;
+  const check = checkFulltext(content, p.title, rawText, p.doi, format === "xml");
+  if (!check.ok) return { ok: false, reason: describe(check.reason, format, content), format };
+  return { ok: true, format, md };
+}
+var ELSEVIER_TAGS = [
+  [/ja:article\b/g, "article"],
+  [/ja:body\b/g, "body"],
+  [/ja:head\b/g, "front"],
+  [/ce:sections\b/g, "sec-group"],
+  [/ce:section-title\b/g, "title"],
+  [/ce:section\b/g, "sec"],
+  [/ce:simple-para\b/g, "p"],
+  [/ce:para\b/g, "p"],
+  [/ce:abstract-sec\b/g, "sec"],
+  [/ce:abstract\b/g, "abstract"],
+  [/ce:title\b/g, "article-title"],
+  [/ce:italic\b/g, "italic"],
+  [/ce:bold\b/g, "bold"],
+  [/ce:sup\b/g, "sup"],
+  [/ce:inf\b/g, "sub"],
+  [/ce:cross-refs?\b/g, "xref"],
+  [/ce:list-item\b/g, "list-item"],
+  [/ce:list\b/g, "list"],
+  [/ce:label\b/g, "label"],
+  [/ce:caption\b/g, "caption"],
+  [/ce:table\b/g, "table-wrap"],
+  [/ce:figure\b/g, "fig"],
+  [/ce:bib-reference\b/g, "ref"],
+  [/ce:bibliography\b/g, "ref-list"],
+  [/sb:reference\b/g, "mixed-citation"],
+  [/ce:acknowledgment\b/g, "ack"],
+  [/ce:inter-ref\b/g, "ext-link"]
+];
+function elsevierToJats(xml) {
+  let out = xml;
+  for (const [re, to] of ELSEVIER_TAGS) out = out.replace(re, to);
+  return out.replace(/<\/?full-text-retrieval-response[^>]*>/g, "").replace(/<\/?originalText[^>]*>/g, "").replace(/<\/?xocs:doc[^>]*>/g, "").replace(/<\/?xocs:serial-item[^>]*>/g, "");
+}
+
+// src/tiers/core.ts
+var WINDOW_MS = 6e4;
+var PER_WINDOW = 10;
+var MAX_WAIT_MS = 65e3;
+var TIMEOUT_MS3 = 1e4;
+var calls = [];
+async function pace() {
+  const now = Date.now();
+  while (calls.length && calls[0] <= now - WINDOW_MS) calls.shift();
+  if (calls.length >= PER_WINDOW) await new Promise((r) => setTimeout(r, calls[0] + WINDOW_MS - now + 200));
+  calls.push(Date.now());
+}
+async function coreFetch(url, key) {
+  const headers = { "User-Agent": LIBRARY_UA, Authorization: `Bearer ${key}` };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    await pace();
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(TIMEOUT_MS3), redirect: "follow" });
+    if (res.ok) return await res.text();
+    const body = await res.text().catch(() => "");
+    if (res.status === 429 && attempt === 0) {
+      const until = Date.parse(res.headers.get("x-ratelimit-retry-after") ?? "");
+      const wait = Number.isFinite(until) ? Math.min(Math.max(until - Date.now(), 1e3), MAX_WAIT_MS) : 1e4;
+      await new Promise((r) => setTimeout(r, wait));
+      continue;
+    }
+    throw new Error(res.status < 500 ? httpReason(res.status, body) : `HTTP ${res.status}`);
+  }
+  throw new Error("HTTP 429");
+}
+function coreTier(apiKey) {
+  const key = apiKey?.trim();
+  return {
+    name: "core",
+    applies: (p) => p.doi ? true : "no doi",
+    async run(p, ctx) {
+      if (!key) return { ...miss(this.name, "needs api key"), skipped: true };
+      let data;
+      try {
+        const q = encodeURIComponent(`doi:"${p.doi}"`);
+        data = JSON.parse(await coreFetch(`https://api.core.ac.uk/v3/search/works/?q=${q}&limit=5`, key));
+      } catch (e) {
+        return miss(this.name, errMsg(e));
+      }
+      const candidates = coreCandidates(data);
+      if (!candidates.length) return miss(this.name, data.results?.length ? "no full text" : "not in core");
+      ctx.onTry?.(`located ${candidates.length} copies`);
+      return download(this.name, p, candidates, ctx);
+    }
+  };
+}
+function coreCandidates(d) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (url, pdf, host) => {
+    if (!url || seen.has(url)) return;
+    seen.add(url);
+    out.push({ url, version: "published", source: "core", host, pdf });
+  };
+  for (const w of d.results ?? []) {
+    add(w.downloadUrl, true, "core");
+    for (const l of w.links ?? []) if (l.type === "download") add(l.url, /\.pdf($|\?)/i.test(l.url ?? ""), "core");
+    for (const u of w.sourceFulltextUrls ?? []) add(u, /\.pdf($|\?)/i.test(u), "repository");
+  }
+  return out;
+}
+
+// src/tiers/europepmc.ts
+var europepmc = {
+  name: "europepmc",
+  applies: (p) => p.pmid ? true : "no pmid",
+  async run(p, ctx) {
+    let data;
+    try {
+      const q = encodeURIComponent(`EXT_ID:${p.pmid} AND SRC:MED`);
+      data = JSON.parse(await fetchText(`https://www.ebi.ac.uk/europepmc/webservices/rest/search?query=${q}&resultType=core&format=json`, { "User-Agent": LIBRARY_UA }));
+    } catch (e) {
+      return miss(this.name, errMsg(e));
+    }
+    const rec = data.resultList?.result?.[0];
+    if (!rec) return miss(this.name, "not in europe pmc");
+    const candidates = europepmcCandidates(rec, p.pmcid);
+    if (!candidates.length) return miss(this.name, "no free copy");
+    ctx.onTry?.(`located ${candidates.length} copies`);
+    return download(this.name, p, candidates, ctx);
+  }
+};
+function europepmcCandidates(r, pmcid) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (url, pdf, host, version) => {
+    if (!url || seen.has(url)) return;
+    seen.add(url);
+    out.push({ url, version, source: "europepmc", host, pdf });
+  };
+  const id = (r.pmcid ?? pmcid ?? "").toUpperCase() || null;
+  const own = r.isOpenAccess === "Y" ? "published" : "accepted_manuscript";
+  if (id && r.inEPMC === "Y") {
+    if (r.isOpenAccess === "Y") add(`https://www.ebi.ac.uk/europepmc/webservices/rest/${id}/fullTextXML`, false, "europepmc", own);
+    if (r.hasPDF === "Y") add(`https://europepmc.org/articles/${id}?pdf=render`, true, "europepmc", own);
+  }
+  for (const u of r.fullTextUrlList?.fullTextUrl ?? []) {
+    if (!u.url || u.site === "DOI" || !/^(F|OA)$/.test(u.availabilityCode ?? "")) continue;
+    if (u.documentStyle === "abs") continue;
+    if (/^https?:\/\/europepmc\.org\/articles\//i.test(u.url) && u.documentStyle === "html") continue;
+    add(u.url, u.documentStyle === "pdf", u.site?.toLowerCase() ?? "unknown", "published");
+  }
+  return out;
+}
+
+// src/tiers/inbox.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, unlinkSync } from "fs";
+import { join as join6 } from "path";
+var INBOX_DIR = join6(AI4L_LIBRARY_DIR, "inbox");
+var EXT = { ".pdf": "application/pdf", ".xml": "text/xml", ".html": "text/html", ".htm": "text/html" };
+function findInboxFile(dir, pmid) {
+  if (!existsSync6(dir)) return null;
+  const re = new RegExp(`(^|[^0-9])${pmid}([^0-9]|$)`);
+  for (const name of readdirSync2(dir).sort()) {
+    const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+    if (ext in EXT && re.test(name.slice(0, -ext.length))) return join6(dir, name);
+  }
+  return null;
+}
+function inboxTier(dir = INBOX_DIR) {
+  return {
+    name: "inbox",
+    always: true,
+    applies: (p) => p.pmid ? true : "no pmid",
+    async run(p, ctx) {
+      const file = findInboxFile(dir, p.pmid);
+      if (!file) return { ...miss("inbox", "no file"), skipped: true, ephemeral: true };
+      const name = file.slice(file.lastIndexOf("/") + 1);
+      const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+      const bytes = readFileSync5(file);
+      const r = await convertBytes(p, bytes, EXT[ext]);
+      if (!r.ok) return miss("inbox", `${name}: ${r.reason}`);
+      ctx.onTry?.(`${name} ok, removed from the inbox`);
+      unlinkSync(file);
+      return { ok: true, tier: "inbox", format: r.format, raw: r.format === "pdf" ? bytes : bytes.toString("utf8"), md: r.md, version: "published" };
+    }
+  };
+}
+var inbox = inboxTier();
+
+// src/tiers/openalex.ts
+var openalex = {
+  name: "openalex",
+  applies: (p) => p.pmid || p.doi ? true : "no pmid or doi",
+  async run(p, ctx) {
+    const mail = contactEmail();
+    const key = p.pmid ? `pmid:${p.pmid}` : `doi:${p.doi}`;
+    let data;
+    try {
+      data = JSON.parse(await fetchText(`https://api.openalex.org/works/${encodeURIComponent(key)}?mailto=${encodeURIComponent(mail)}`, { "User-Agent": LIBRARY_UA }));
+    } catch (e) {
+      return miss(this.name, errMsg(e));
+    }
+    const candidates = openalexCandidates(data);
+    if (!candidates.length) return miss(this.name, data.open_access?.is_oa === false ? "closed" : "no oa copy");
+    ctx.onTry?.(`located ${candidates.length} copies`);
+    return download(this.name, p, candidates, ctx);
+  }
+};
+function openalexCandidates(d) {
+  const locs = [...d.best_oa_location ? [d.best_oa_location] : [], ...d.locations ?? []].filter((l) => l.is_oa);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const l of locs) {
+    for (const [url, pdf] of [[l.pdf_url, true], [l.landing_page_url, false]]) {
+      if (!url || seen.has(url) || /doi\.org\//.test(url)) continue;
+      seen.add(url);
+      out.push({ url, version: oaVersion(l.version), source: "openalex", host: l.source?.display_name ?? "unknown", pdf });
+    }
+  }
+  return out;
+}
+
+// src/tiers/pmc.ts
+function pmcEfetchUrl(pmcid) {
+  const u = new URL("https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi");
+  u.searchParams.set("db", "pmc");
+  u.searchParams.set("id", pmcid.replace(/^PMC/i, ""));
+  u.searchParams.set("retmode", "xml");
+  if (process.env.NCBI_API_KEY) u.searchParams.set("api_key", process.env.NCBI_API_KEY);
+  u.searchParams.set("tool", "ai4l-library");
+  u.searchParams.set("email", contactEmail());
+  return u.toString();
+}
+var pmc = {
+  name: "pmc",
+  applies: (p) => p.pmcid ? true : "no pmcid",
+  async run(p) {
+    let xml;
+    try {
+      xml = await fetchText(pmcEfetchUrl(p.pmcid));
+    } catch (e) {
+      return miss(this.name, errMsg(e));
+    }
+    const doc = parseJats(xml);
+    if (!doc.hasBody) return miss(this.name, "no body");
+    const md = renderFulltextMd(doc, p.headLine);
+    const check = checkFulltext(md, p.title);
+    if (!check.ok) return miss(this.name, check.reason);
+    return { ok: true, tier: this.name, format: "xml", raw: xml, md, version: "published" };
+  }
+};
+
+// src/tiers/tdm.ts
+var CROSSREF = "https://api.crossref.org/works/";
+var TOKENED = [
+  { host: /(^|\.)api\.elsevier\.com$/i, key: "elsevier", env: "ELSEVIER_API_KEY", header: "X-ELS-APIKey" },
+  { host: /(^|\.)api\.wiley\.com$/i, key: "wiley", env: "WILEY_TDM_TOKEN", header: "Wiley-TDM-Client-Token" }
+];
+var hostOf2 = (url) => {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+};
+function tdmCandidates(work, tokens = {}, env = process.env) {
+  const links = (work.message?.link ?? []).filter((l) => l["intended-application"] === "text-mining" && l.URL);
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const missingTokens = /* @__PURE__ */ new Set();
+  for (const l of links) {
+    const ct = (l["content-type"] ?? "").toLowerCase();
+    if (seen.has(l.URL)) {
+      const prev = candidates.find((c) => c.url === l.URL);
+      if (prev && /pdf/.test(ct)) prev.pdf = true;
+      continue;
+    }
+    seen.add(l.URL);
+    const rule = TOKENED.find((r) => r.host.test(hostOf2(l.URL)));
+    let headers;
+    if (rule) {
+      const token = tokens[rule.key]?.trim() || env[rule.env]?.trim();
+      if (!token) {
+        missingTokens.add(rule.key);
+        continue;
+      }
+      headers = { [rule.header]: token };
+    }
+    if (/text\/plain/.test(ct)) continue;
+    candidates.push({ url: l.URL, version: "published", source: "tdm", host: work.message?.publisher ?? hostOf2(l.URL), pdf: /pdf/.test(ct) || /\.pdf(\?|$)/i.test(l.URL), headers });
+  }
+  const rank = (c) => /\/xml|text\/xml/.test(c.url) ? 0 : c.pdf ? 1 : 2;
+  candidates.sort((a, b) => rank(a) - rank(b));
+  return { candidates, missingTokens: [...missingTokens] };
+}
+function tdmTier(tokens = {}) {
+  return {
+    name: "tdm",
+    applies: (p) => p.doi ? true : "no doi",
+    async run(p, ctx) {
+      let work;
+      try {
+        work = JSON.parse(await fetchText(CROSSREF + encodeURIComponent(p.doi), { "User-Agent": `${LIBRARY_UA} (mailto:${contactEmail()})` }));
+      } catch (e) {
+        return miss(this.name, errMsg(e));
+      }
+      const { candidates, missingTokens } = tdmCandidates(work, tokens);
+      if (!candidates.length) return missingTokens.length ? { ...miss(this.name, `needs ${missingTokens.join("/")} token`), skipped: true } : miss(this.name, "no text-mining links");
+      ctx.onTry?.(`${candidates.length} text-mining links${missingTokens.length ? ` (skipped hosts needing ${missingTokens.join("/")} token)` : ""}`);
+      return download(this.name, p, candidates, ctx);
+    }
+  };
+}
+var tdm = tdmTier();
+
+// src/tiers/unpaywall.ts
+var unpaywall = {
+  name: "unpaywall",
+  applies: (p) => p.doi ? true : "no doi",
+  async run(p, ctx) {
+    const mail = contactEmail();
+    let data;
+    try {
+      data = JSON.parse(await fetchText(`https://api.unpaywall.org/v2/${encodeURIComponent(p.doi)}?email=${encodeURIComponent(mail)}`, { "User-Agent": LIBRARY_UA }));
+    } catch (e) {
+      return miss(this.name, errMsg(e));
+    }
+    const candidates = unpaywallCandidates(data);
+    if (!candidates.length) return miss(this.name, data.is_oa === false ? "closed" : "no oa copy");
+    ctx.onTry?.(`located ${candidates.length} copies`);
+    return download(this.name, p, candidates, ctx);
+  }
+};
+function unpaywallCandidates(d) {
+  const locs = [...d.best_oa_location ? [d.best_oa_location] : [], ...d.oa_locations ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const l of locs) {
+    for (const [url, pdf] of [[l.url_for_pdf, true], [l.url ?? l.url_for_landing_page, false]]) {
+      if (!url || seen.has(url)) continue;
+      seen.add(url);
+      out.push({ url, version: oaVersion(l.version), source: "unpaywall", host: l.host_type ?? "unknown", pdf });
+    }
+  }
+  return out;
+}
+
+// src/tiers/index.ts
+var BUILTIN = [
+  { name: "inbox", make: () => inbox },
+  { name: "pmc", make: () => pmc },
+  { name: "europepmc", make: () => europepmc },
+  { name: "tdm", make: (o) => tdmTier(o.tokens ?? {}) },
+  { name: "unpaywall", make: () => unpaywall },
+  { name: "openalex", make: () => openalex },
+  { name: "core", make: (o) => coreTier(o.api_key) }
+];
+
+// src/tiers/url.ts
+var PLACEHOLDERS = ["doi", "pmid", "pmcid"];
+function urlTier(name, template, headers) {
+  const used = PLACEHOLDERS.filter((k) => template.includes(`{${k}}`));
+  return {
+    name,
+    applies(p) {
+      const missing = used.filter((k) => !p[k]);
+      return missing.length ? `no ${missing.join("/")}` : true;
+    },
+    async run(p, ctx) {
+      if (!used.length) return miss(name, "template has no placeholder");
+      const url = used.reduce((u, k) => u.replaceAll(`{${k}}`, encodeURIComponent(p[k])), template);
+      return download(name, p, [{ url, version: "published", source: name, host: "user", pdf: /\.pdf(\?|$)/i.test(url), headers, service: true }], ctx);
+    }
+  };
+}
+
+// src/config.ts
+var CONFIG_FILE = process.env.AI4L_LIBRARY_CONFIG?.trim() || join7(AI4L_LIBRARY_DIR, "config.json");
+function resolveEnv(v, env = process.env) {
+  return v.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => env[n] ?? "");
+}
+var resolveMap = (m) => m ? Object.fromEntries(Object.entries(m).map(([k, v]) => [k, resolveEnv(String(v))])) : void 0;
+function settings(file = CONFIG_FILE) {
+  const out = { retry_after_days: 1, retry_blocked: false, refresh_after_days: 30 };
+  if (!existsSync7(file)) return out;
+  try {
+    const cfg = JSON.parse(readFileSync6(file, "utf8"));
+    if (typeof cfg.retry_after_days === "number" && cfg.retry_after_days >= 0) out.retry_after_days = cfg.retry_after_days;
+    if (typeof cfg.retry_blocked === "boolean") out.retry_blocked = cfg.retry_blocked;
+    if (typeof cfg.refresh_after_days === "number" && cfg.refresh_after_days >= 0) out.refresh_after_days = cfg.refresh_after_days;
+  } catch {
+  }
+  return out;
+}
+function resolveTiers(env = process.env.AI4L_LIBRARY_TIERS, file = CONFIG_FILE) {
+  const problems = [];
+  const builtin = new Map(BUILTIN.map((t) => [t.name, t]));
+  const known = /* @__PURE__ */ new Map();
+  let source = "default";
+  for (const t of BUILTIN) known.set(t.name, { tier: t.make({}), enabled: true, kind: "builtin" });
+  if (existsSync7(file)) {
+    source = "file";
+    let cfg = {};
+    try {
+      cfg = JSON.parse(readFileSync6(file, "utf8"));
+    } catch (e) {
+      problems.push(`${file}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (Array.isArray(cfg.tiers)) {
+      for (const k of known.keys()) known.get(k).enabled = false;
+      const ordered = /* @__PURE__ */ new Map();
+      for (const e of cfg.tiers) {
+        if (!e || typeof e.name !== "string" || !e.name.trim()) {
+          problems.push(`${file}: tier entry without name`);
+          continue;
+        }
+        const enabled = e.enabled !== false;
+        const description = typeof e.description === "string" ? e.description : void 0;
+        if (typeof e.url === "string" && e.url.trim()) ordered.set(e.name, { tier: urlTier(e.name, resolveEnv(e.url.trim()), resolveMap(e.headers)), enabled, kind: "url", description });
+        else if (builtin.has(e.name)) ordered.set(e.name, { tier: builtin.get(e.name).make({ tokens: resolveMap(e.tokens), api_key: typeof e.api_key === "string" ? resolveEnv(e.api_key) : void 0 }), enabled, kind: "builtin", description });
+        else problems.push(`${file}: unknown tier "${e.name}" (built-in: ${[...builtin.keys()].join(", ")}; a user tier needs "url")`);
+      }
+      for (const [k, v] of known) if (!ordered.has(k)) ordered.set(k, v);
+      known.clear();
+      for (const [k, v] of ordered) known.set(k, v);
+    }
+  }
+  if (env && env.trim()) {
+    source = "env";
+    for (const v of known.values()) v.enabled = false;
+    const ordered = /* @__PURE__ */ new Map();
+    for (const name of env.split(",").map((s) => s.trim()).filter(Boolean)) {
+      const v = known.get(name);
+      if (!v) {
+        problems.push(`AI4L_LIBRARY_TIERS: unknown tier "${name}"`);
+        continue;
+      }
+      ordered.set(name, { ...v, enabled: true });
+    }
+    for (const [k, v] of known) if (!ordered.has(k)) ordered.set(k, v);
+    known.clear();
+    for (const [k, v] of ordered) known.set(k, v);
+  }
+  const all = [...known.entries()].map(([name, v]) => ({ name, enabled: v.enabled, description: v.description ?? (v.kind === "url" ? "url tier" : "built-in") }));
+  return { tiers: [...known.values()].filter((v) => v.enabled).map((v) => v.tier), all, source, file, problems };
+}
+
+// src/cascade.ts
+var PERMANENT = /^(no pmcid|no doi|no pmid|no pmid or doi|no body|closed|no oa copy|no free copy|not in core|no full text|xml without body|template has no placeholder|title missing|title not in text|no methods\/results|no article body|scanned pdf|not a pdf|only copies already tried|only pmc copies|nothing located|unknown content|no text-mining links|needs [a-z/]+ token)/i;
+var BLOCKED = /^(challenge not cleared|empty response)/i;
+var RUNG = /^(browser [^:]+|brightdata|unlocker): /;
+function isPermanent(reason, retryBlocked = false) {
+  return reason.split(";").every((r) => {
+    const b = r.trim().replace(RUNG, "");
+    return PERMANENT.test(b) || !retryBlocked && BLOCKED.test(b);
+  });
+}
+function parseAttempt(a) {
+  const m = /^(\S+) \((.*)\)(?: (\d{4}-\d{2}-\d{2}))?$/.exec(a.trim());
+  return m ? { tier: m[1], reason: m[2], date: m[3] ?? null } : null;
+}
+var attemptLabel = (m, date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) => `${m.tier} (${m.reason}) ${date}`;
+function shouldSkip(attempts, tier, retryAfterDays, now = /* @__PURE__ */ new Date(), retryBlocked = false) {
+  for (const a of attempts) {
+    const p = parseAttempt(a);
+    if (!p || p.tier !== tier) continue;
+    if (isPermanent(p.reason, retryBlocked)) return true;
+    if (!p.date) return false;
+    const age = (now.getTime() - new Date(p.date).getTime()) / 864e5;
+    return age < retryAfterDays;
+  }
+  return false;
+}
+async function fulltextCascade(p, attempts, onEvent, tiers = resolveTiers().tiers, retryAfterDays = settings().retry_after_days, retryBlocked = settings().retry_blocked) {
+  const misses = [];
+  const tried = /* @__PURE__ */ new Set();
+  for (const tier of tiers) {
+    if (!tier.always && shouldSkip(attempts, tier.name, retryAfterDays, /* @__PURE__ */ new Date(), retryBlocked)) continue;
+    const applies = tier.applies(p);
+    const ctx = { tried, onTry: (message) => onEvent?.({ ok: "try", tier: tier.name, message }) };
+    const r = applies === true ? await tier.run(p, ctx) : { ...miss(tier.name, applies), skipped: true };
+    onEvent?.(r);
+    if (r.ok) return { hit: r, misses };
+    misses.push(r);
+  }
+  return { hit: null, misses };
+}
+
+// src/ids.ts
+var SUPPORTED = /* @__PURE__ */ new Set(["pmid", "dailymed", "nct", "doi"]);
+var KNOWN = /* @__PURE__ */ new Set(["pmid", "pmc", "doi", "nct", "dailymed"]);
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function parseId(raw) {
+  const requested = String(raw ?? "").trim();
+  const bare2 = /^\d+$/.test(requested);
+  const bareNct = /^NCT\d{8}$/i.test(requested);
+  const m = bare2 || bareNct ? null : /^([A-Za-z][A-Za-z0-9_-]*):(.+)$/.exec(requested);
+  if (!bare2 && !bareNct && !m) return { requested, type: null, id: null, error: "invalid id" };
+  const type = bare2 ? "pmid" : bareNct ? "nct" : m[1].toLowerCase();
+  const value = bare2 || bareNct ? requested : m[2].trim();
+  if (!KNOWN.has(type)) return { requested, type, id: value, error: "invalid id" };
+  if (!SUPPORTED.has(type)) return { requested, type, id: value, error: "type not supported yet" };
+  if (type === "doi") {
+    const v = value.replace(/^https?:\/\/(dx\.)?doi\.org\//i, "").replace(/^doi:\s*/i, "").trim().toLowerCase();
+    return /^10\.\d{4,9}\/\S+$/.test(v) ? { requested, type, id: v } : { requested, type, id: value, error: "invalid id" };
+  }
+  if (type === "nct") {
+    const v = value.toUpperCase().replace(/^NCT/, "");
+    return /^\d{8}$/.test(v) ? { requested, type, id: v } : { requested, type, id: value, error: "invalid id" };
+  }
+  if (type === "dailymed") {
+    const v = value.toLowerCase();
+    return UUID.test(v) ? { requested, type, id: v } : { requested, type, id: value, error: "invalid id" };
+  }
+  if (!/^[1-9]\d*$/.test(value)) return { requested, type, id: value, error: "invalid id" };
+  return { requested, type, id: value };
+}
+
+// src/info.ts
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
+
+// src/verify.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+var DEFAULT_MODEL = "pplx-decider-flash-v1.2";
+var QUESTION = "Does the paper state this, in substance? Ignore section labels and definitions of terms in parentheses. Every fact and number of the statement must be stated in the paper or follow from its numbers; a rounded number counts. If any part of the statement is absent from the paper or contradicted by it, answer false.";
+function verifyConfig(file = CONFIG_FILE) {
+  if (!existsSync8(file)) return null;
+  try {
+    const v = JSON.parse(readFileSync7(file, "utf8")).verify;
+    if (!v || typeof v.base_url !== "string") return null;
+    const base_url = resolveEnv(v.base_url).trim().replace(/\/+$/, "");
+    if (!base_url) return null;
+    const key = typeof v.api_key === "string" ? resolveEnv(v.api_key).trim() : "";
+    return {
+      base_url,
+      api_key: key || null,
+      model: typeof v.model === "string" && resolveEnv(v.model).trim() ? resolveEnv(v.model).trim() : DEFAULT_MODEL,
+      threshold: typeof v.threshold === "number" && v.threshold > 0 && v.threshold < 1 ? v.threshold : 0.5,
+      // Hosted takes 256k tokens in one request (a 50k-token paper in 2 s); the
+      // Mac app is limited to 32k and slows steeply beyond 25k, so it windows.
+      window_chars: typeof v.window_chars === "number" && v.window_chars >= 1e4 ? v.window_chars : isHosted(base_url) ? 8e5 : 9e4,
+      timeout_seconds: typeof v.timeout_seconds === "number" && v.timeout_seconds > 0 ? v.timeout_seconds : 60
+    };
+  } catch {
+    return null;
+  }
+}
+var isHosted = (baseUrl) => {
+  try {
+    return new URL(baseUrl).hostname === "api.perplexity.ai";
+  } catch {
+    return false;
+  }
+};
+function isLocal(baseUrl) {
+  try {
+    const h = new URL(baseUrl).hostname;
+    return h === "localhost" || /^127\./.test(h) || h === "::1" || /^10\./.test(h) || /^192\.168\./.test(h) || /^172\.(1[6-9]|2\d|3[01])\./.test(h) || /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(h);
+  } catch {
+    return false;
+  }
+}
+function cleanMarkdown(md) {
+  return md.replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\]\([^)]*\)/g, "]").replace(/^\s*#+\s*(see more about|more for you|back to top)\b.*$/gim, "").replace(/\n{3,}/g, "\n\n");
+}
+function windows(md, max) {
+  const out = [];
+  let cur = "";
+  for (const s of cleanMarkdown(md).split(/\n(?=#)/)) {
+    if (cur && cur.length + s.length + 1 > max) {
+      out.push(cur);
+      cur = "";
+    }
+    cur += (cur ? "\n" : "") + s.slice(0, max);
+  }
+  if (cur) out.push(cur);
+  return out.length ? out : [""];
+}
+function citationGroups(claim) {
+  const one = /[(\[][^()\[\]]*?\b(1[89]\d\d|20\d\d)[a-z]?\b[^()\[\]]*[)\]]/g;
+  const groups = [];
+  let last = -1;
+  for (const m of claim.matchAll(one)) {
+    const between = claim.slice(last, m.index);
+    if (last >= 0 && /^[\s;,]*(and|&)?[\s;,]*$/i.test(between)) {
+      groups[groups.length - 1] += between + m[0];
+    } else groups.push(m[0]);
+    last = m.index + m[0].length;
+  }
+  return groups;
+}
+function fragment(claim) {
+  const body = claim.trim().replace(/^[-*+]\s+/, "").replace(/^\*\*[^*]+:\*\*\s*/, "").replace(/^[("'\u201c]+/, "");
+  const first = /^(\S+)/.exec(body)?.[1] ?? "";
+  if (/^(and|or|but|nor|which|whereas|while)$/i.test(first.replace(/[,;:]$/, ""))) return `claim is a fragment: starts with "${first}" \u2014 send a complete statement with its subject`;
+  if (/^[a-z]/.test(body)) return `claim is a fragment: starts with "${first}" in lowercase \u2014 send a complete statement with its subject`;
+  return null;
+}
+var SUPERSEDED = "The corrected text replaces figures that the paper first published wrongly. Does the statement give a figure for a quantity the corrected text also gives, but with a different value \u2014 the superseded, uncorrected figure? If the statement's figures match the corrected text, or it concerns something the corrected text does not cover, answer false.";
+function correctedText(md) {
+  const i = md.indexOf(`
+${CORRECTED_HEADING}
+`);
+  if (i < 0) return null;
+  return md.slice(i + CORRECTED_HEADING.length + 2).split("\n").filter((l) => l.trim() && !/^NLM corrected these sentences/.test(l)).join("\n").trim() || null;
+}
+function decider(cfg, fetchFn = fetch) {
+  return async (state, questions) => {
+    const headers = { "content-type": "application/json" };
+    if (cfg.api_key) headers.authorization = `Bearer ${cfg.api_key}`;
+    const body = JSON.stringify({ model: cfg.model, state, questions });
+    let r;
+    try {
+      r = await fetchFn(`${cfg.base_url}/v1/decisions`, { method: "POST", headers, body, signal: AbortSignal.timeout(cfg.timeout_seconds * 1e3) });
+    } catch (e) {
+      const name = e instanceof Error ? e.name : "";
+      const cause = e.cause;
+      if (name === "TimeoutError" || name === "AbortError" || cause?.code === "UND_ERR_HEADERS_TIMEOUT") throw new Error(`${cfg.model}: no answer within ${cfg.timeout_seconds}s (${body.length} chars)`);
+      throw new Error(`${cfg.model}: ${cause?.message ?? (e instanceof Error ? e.message : String(e))}`);
+    }
+    const j = await r.json().catch(() => ({}));
+    if (j.answers) return j.answers;
+    const msg = typeof j.error === "string" ? j.error : j.error?.message;
+    throw new Error(msg ? `${cfg.model}: ${msg}` : `${cfg.model}: HTTP ${r.status} without an answer`);
+  };
+}
+async function readPaper(raw, libraryDir = AI4L_LIBRARY_DIR) {
+  const p = parseId(raw);
+  if (p.error) return { id: p.requested, error: p.error };
+  const paths = entryPaths(libraryDir, p.type, p.id);
+  if (!entryExists(paths)) return { id: p.requested, error: "not in library" };
+  const full = existsSync8(paths.fulltextMd);
+  if (full) return { id: p.requested, basis: "full_text", text: readFileSync7(paths.fulltextMd, "utf8") };
+  const meta = readMeta(paths);
+  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync7(paths.md, "utf8") };
+}
+async function verifyClaim(claim, id, cfg, decide, read = readPaper) {
+  const out = { claim, id, verdict: "error", score: null, basis: null, windows: 0, glyphs_unresolved: 0, superseded: null, model: cfg?.model ?? null };
+  const words2 = claim.trim().split(/\s+/).filter(Boolean).length;
+  if (!words2) return { ...out, error: "claim empty" };
+  if (words2 < 4) return { ...out, error: "claim too short to be a finding" };
+  const frag = fragment(claim);
+  if (frag) return { ...out, error: frag };
+  const groups = citationGroups(claim);
+  if (groups.length) return { ...out, error: groups.length > 1 ? `compound claim: ${groups.length} citation groups ${groups.join(" ")} \u2014 one finding per call, without its sources` : `claim names a source ${groups[0]} \u2014 send the finding without its sources; the paper is the id` };
+  const paper = await read(id);
+  out.id = paper.id;
+  if ("error" in paper) return { ...out, error: paper.error };
+  if (!cfg || !decide) return { ...out, error: "no verify model configured (config.json: verify)" };
+  out.basis = paper.basis;
+  out.glyphs_unresolved = countUnresolved(paper.text);
+  if (paper.basis === "title") return { ...out, verdict: "na" };
+  const ws = windows(paper.text, cfg.window_chars);
+  out.windows = ws.length;
+  try {
+    let score = 0;
+    for (const w of ws) {
+      const a = await decide({ paper: w, statement: claim }, { backed: { type: "noul", instructions: QUESTION } });
+      score = Math.max(score, a.backed?.noul ?? 0);
+    }
+    out.score = score;
+    const corrected = correctedText(paper.text);
+    if (corrected) {
+      const a = await decide({ corrected, statement: claim }, { superseded: { type: "noul", instructions: SUPERSEDED } });
+      out.superseded = (a.superseded?.noul ?? 0) >= 0.5;
+    }
+  } catch (e) {
+    return { ...out, error: e instanceof Error ? e.message : String(e) };
+  }
+  if (out.score >= cfg.threshold) return { ...out, verdict: "pass" };
+  return { ...out, verdict: paper.basis === "full_text" ? "fail" : "na" };
+}
+
+// src/info.ts
+function* metaFiles(dir) {
+  if (!existsSync9(dir)) return;
+  for (const name of readdirSync3(dir)) {
+    const p = join8(dir, name);
+    if (statSync(p).isDirectory()) yield* metaFiles(p);
+    else if (name.endsWith("-meta.md")) yield p;
+  }
+}
+var human = (n) => {
+  const u = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let i = 0;
+  while (n >= 1024 && i < u.length - 1) {
+    n /= 1024;
+    i++;
+  }
+  return i ? `${n.toFixed(1)} ${u[i]}` : `${n} B`;
+};
+function field(md, key) {
+  const m = new RegExp(`^${key}:\\s*(.*)$`, "m").exec(md);
+  return m ? m[1].trim() : "";
+}
+function libraryInfo(libraryDir, host, withIds, tiers = resolveTiers()) {
+  const info = {
+    library_dir: libraryDir,
+    host,
+    tiers: tiers.all,
+    tiers_config: { source: tiers.source, file: tiers.file, problems: tiers.problems, retry_after_days: settings().retry_after_days, retry_blocked: settings().retry_blocked },
+    download: downloadInfo(),
+    verify: verifyInfo(),
+    entries: 0,
+    size_bytes: 0,
+    size: "",
+    by_type: {},
+    by_level: {},
+    types: {},
+    retracted: 0,
+    not_citable: 0,
+    errata: 0,
+    concerns: 0,
+    updates: 0
+  };
+  const ids = [];
+  for (const type of existsSync9(libraryDir) ? readdirSync3(libraryDir) : []) {
+    const typeDir = join8(libraryDir, type);
+    if (!statSync(typeDir).isDirectory()) continue;
+    for (const meta of metaFiles(typeDir)) {
+      const md = readFileSync8(meta, "utf8");
+      const raw = field(md, "level") || "unknown";
+      const level = raw === "abstract" && field(md, "has_abstract") === "no" ? "title" : raw;
+      info.entries++;
+      info.by_type[type] = (info.by_type[type] ?? 0) + 1;
+      info.by_level[level] = (info.by_level[level] ?? 0) + 1;
+      const t = info.types[type] ??= { entries: 0, full_text: 0, abstract: 0, title: 0, retracted: 0 };
+      t.entries++;
+      if (level === "full_text" || level === "abstract" || level === "title") t[level]++;
+      const dir = dirname2(meta);
+      for (const f of readdirSync3(dir)) {
+        try {
+          const st = statSync(join8(dir, f));
+          if (st.isFile()) info.size_bytes += st.size;
+        } catch {
+        }
+      }
+      const types = noticeTypes(md, meta);
+      if (field(md, "retracted") === "yes" || types.has("retraction_in") || types.has("partial_retraction_in") || types.has("retracted_and_republished_in")) {
+        info.retracted++;
+        info.not_citable++;
+        t.retracted++;
+      }
+      if (types.has("erratum_in")) info.errata++;
+      if (types.has("expression_of_concern_in")) info.concerns++;
+      if (types.has("update_in")) info.updates++;
+      if (withIds) ids.push(`${type}:${field(md, type) || meta.split("/").slice(-2, -1)[0]}`);
+    }
+  }
+  if (withIds) info.ids = ids.sort();
+  info.size = human(info.size_bytes);
+  return info;
+}
+var XML_TYPES = { ErratumIn: "erratum_in", RetractionIn: "retraction_in", PartialRetractionIn: "partial_retraction_in", RetractedandRepublishedIn: "retracted_and_republished_in", ExpressionOfConcernIn: "expression_of_concern_in", UpdateIn: "update_in" };
+function noticeTypes(md, metaPath) {
+  const out = /* @__PURE__ */ new Set();
+  if (/^pubmed_checked:/m.test(md)) {
+    for (const m of md.matchAll(/^corrections:\s*(\S+)/gm)) out.add(m[1]);
+    return out;
+  }
+  try {
+    const xml = readFileSync8(metaPath.replace(/-meta\.md$/, "-abstract.xml"), "utf8");
+    for (const m of xml.matchAll(/<CommentsCorrections RefType="([A-Za-z]+)"/g)) if (XML_TYPES[m[1]]) out.add(XML_TYPES[m[1]]);
+  } catch {
+  }
+  return out;
+}
+function verifyInfo() {
+  const v = verifyConfig();
+  return v ? { model: v.model, base_url: v.base_url, local: isLocal(v.base_url) } : null;
+}
+function downloadInfo() {
+  const browsers = browserRungs().map((b) => b.available ? b : { ...b, note: `not installed: ${INSTALL_HINT}` });
+  return { fetch: true, browsers, unlocker: unlockerConfigured() };
+}
+
+// src/read.ts
+function sections(md) {
+  const lines = md.split("\n");
+  const out = [];
+  lines.forEach((l, i) => {
+    const m = /^(#{1,6})\s+(.*\S)\s*$/.exec(l);
+    if (m) out.push({ level: m[1].length, heading: m[2], start: i, end: lines.length, words: 0 });
+  });
+  for (let i = 0; i < out.length; i++) {
+    for (let j = i + 1; j < out.length; j++) {
+      if (out[j].level <= out[i].level) {
+        out[i].end = out[j].start;
+        break;
+      }
+    }
+    out[i].words = countWords(lines.slice(out[i].start + 1, out[i].end).join("\n"));
+  }
+  return out;
+}
+var countWords = (s) => (s.replace(/^#{1,6}\s+/gm, "").match(/\S+/g) ?? []).length;
+function outline(md, text3) {
+  return { text: text3, words: countWords(md), sections: sections(md).filter((s) => s.level > 1).map(({ level, heading, words: words2 }) => ({ level, heading, words: words2 })) };
+}
+function readSection(md, name, maxChars) {
+  const q = name.trim().toLowerCase().replace(/^#+\s*/, "");
+  if (!q) return null;
+  const hits = sections(md).filter((s2) => s2.level > 1 && s2.heading.toLowerCase().includes(q)).sort((a, b) => a.heading.length - b.heading.length);
+  const s = hits[0];
+  if (!s) return null;
+  const lines = md.split("\n");
+  const body = lines.slice(s.start + 1, s.end).join("\n").trim();
+  const truncated = body.length > maxChars;
+  return { heading: s.heading, words: countWords(body), text: truncated ? body.slice(0, maxChars) + "\n\n[truncated]" : body, truncated };
+}
+function search(md, query, maxHits) {
+  const terms = query.toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}\-'.%]*/gu) ?? [];
+  if (!terms.length) return [];
+  const secs = sections(md);
+  const lines = md.split("\n");
+  const sectionAt = (i) => {
+    let h = "";
+    for (const s of secs) {
+      if (s.start <= i) h = s.heading;
+      else break;
+    }
+    return h;
+  };
+  const out = [];
+  let para2 = [];
+  let paraStart = 0;
+  const flush = (endIdx) => {
+    const text3 = para2.join("\n").trim();
+    para2 = [];
+    if (!text3 || /^#{1,6}\s/.test(text3) || /^\|?\s*-{3,}/.test(text3)) return;
+    const low = text3.toLowerCase();
+    let hits = 0;
+    for (const t of terms) {
+      const re = new RegExp(`(^|[^\\p{L}\\p{N}])${escape(t)}(?=$|[^\\p{L}\\p{N}])`, "giu");
+      const n = (low.match(re) ?? []).length;
+      if (!n) return;
+      hits += n;
+    }
+    out.push({ section: sectionAt(paraStart), text: text3, hits });
+    void endIdx;
+  };
+  lines.forEach((l, i) => {
+    if (!l.trim()) {
+      flush(i);
+      paraStart = i + 1;
+      return;
+    }
+    if (/^#{1,6}\s/.test(l)) {
+      flush(i);
+      paraStart = i + 1;
+      return;
+    }
+    if (!para2.length) paraStart = i;
+    para2.push(l);
+  });
+  flush(lines.length);
+  return out.sort((a, b) => b.hits - a.hits).slice(0, maxHits);
+}
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// src/log.ts
+import { appendFileSync, mkdirSync as mkdirSync3, renameSync as renameSync2, statSync as statSync2 } from "fs";
+import { hostname } from "os";
+import { join as join9 } from "path";
+var HOST = hostname();
+var LOG_FILE = join9(AI4L_LIBRARY_DIR, "library.log");
+function stamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+var LOG_MAX_BYTES = 50 * 1024 * 1024;
+function rotateIfLarge(file, max = LOG_MAX_BYTES) {
+  let size = 0;
+  try {
+    size = statSync2(file).size;
+  } catch {
+    return false;
+  }
+  if (size <= max) return false;
+  try {
+    renameSync2(file, `${file}.1`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function log(tool, id, message) {
+  const clean = message.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s*\n\s*/g, " | ");
+  const line = `${stamp()} ${HOST} ${tool.replace(/^library_/, "")} ${id ?? "-"} ${clean}
+`;
+  try {
+    mkdirSync3(AI4L_LIBRARY_DIR, { recursive: true });
+    rotateIfLarge(LOG_FILE);
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+}
+
+// src/doi.ts
+var NCBI_ESEARCH = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi";
+async function pmidForDoi(doi) {
+  const u = new URL(NCBI_ESEARCH);
+  u.searchParams.set("db", "pubmed");
+  u.searchParams.set("term", `${doi}[doi]`);
+  u.searchParams.set("retmode", "json");
+  if (process.env.NCBI_API_KEY) u.searchParams.set("api_key", process.env.NCBI_API_KEY);
+  u.searchParams.set("tool", "ai4l-library");
+  u.searchParams.set("email", contactEmail());
+  const j = JSON.parse(await fetchText(u.toString()));
+  const ids = j.esearchresult?.idlist ?? [];
+  return ids.length === 1 ? ids[0] : null;
+}
+async function fetchCrossref(doi) {
+  try {
+    return await fetchText(`https://api.crossref.org/works/${encodeURIComponent(doi)}?mailto=${encodeURIComponent(contactEmail())}`, { "User-Agent": LIBRARY_UA });
+  } catch (e) {
+    if (/HTTP 404/.test(e instanceof Error ? e.message : String(e))) return null;
+    throw new Error(`crossref fetch failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+var TYPES = {
+  "journal-article": "Journal Article",
+  "proceedings-article": "Conference Paper",
+  "posted-content": "Preprint",
+  "book-chapter": "Book Chapter",
+  "book": "Book",
+  "monograph": "Book",
+  "report": "Report",
+  "dissertation": "Dissertation",
+  "peer-review": "Peer Review",
+  "dataset": "Dataset",
+  "other": "Other"
+};
+var UPDATES = {
+  retraction: "retraction_in",
+  withdrawal: "retraction_in",
+  removal: "retraction_in",
+  "partial-retraction": "partial_retraction_in",
+  correction: "erratum_in",
+  erratum: "erratum_in",
+  corrigendum: "erratum_in",
+  clarification: "erratum_in",
+  addendum: "erratum_in",
+  "expression-of-concern": "expression_of_concern_in",
+  "new-version": "update_in"
+};
+var decode = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+var text2 = (s) => decode(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+function parseCrossref(json2) {
+  let m;
+  try {
+    m = JSON.parse(json2)?.message;
+  } catch {
+    return null;
+  }
+  if (!m?.DOI) return null;
+  const authors = (m.author ?? []).map((a) => a.family ? [a.family, String(a.given ?? "").split(/[\s-]+/).filter(Boolean).map((g) => g[0]).join("")].filter(Boolean).join(" ") : a.name ?? "").filter(Boolean);
+  const first = (m.author ?? [])[0];
+  const date = m.issued?.["date-parts"]?.[0] ?? m.published?.["date-parts"]?.[0] ?? m.created?.["date-parts"]?.[0];
+  const abstract = [];
+  const raw = String(m.abstract ?? "");
+  const secs = [...raw.matchAll(/<jats:sec>\s*(?:<jats:title>([\s\S]*?)<\/jats:title>)?([\s\S]*?)<\/jats:sec>/g)];
+  if (secs.length) for (const s of secs) {
+    const t = text2(s[2]);
+    if (t) abstract.push({ label: s[1] ? text2(s[1]).replace(/[:.]$/, "") : null, text: t });
+  }
+  else {
+    const t = text2(raw.replace(/<jats:title>[\s\S]*?<\/jats:title>/, ""));
+    if (t) abstract.push({ label: null, text: t });
+  }
+  const corrections = (m["updated-by"] ?? []).flatMap((u) => {
+    const type = UPDATES[String(u.type ?? "").toLowerCase()];
+    return type ? [{ type, pmid: null, source: `${u.label ?? u.type}: doi:${u.DOI}${u.updated?.["date-time"] ? ` (${String(u.updated["date-time"]).slice(0, 10)})` : ""}` }] : [];
+  });
+  const funding = [];
+  for (const f of m.funder ?? []) {
+    const n = text2(String(f.name ?? ""));
+    if (n && !funding.includes(n)) funding.push(n);
+  }
+  return {
+    pmid: "",
+    pmcid: null,
+    doi: String(m.DOI).toLowerCase(),
+    title: text2(String((m.title ?? [])[0] ?? "")) || String(m.DOI),
+    authors,
+    firstAuthor: first ? first.family ?? first.name ?? null : null,
+    journal: text2(String((m["container-title"] ?? [])[0] ?? "")) || m.publisher || null,
+    year: date?.[0] ? String(date[0]) : null,
+    publicationTypes: [TYPES[m.type] ?? "Other"],
+    abstract,
+    corrections,
+    coi: null,
+    funding
+  };
+}
+function fromInvertedIndex(index) {
+  if (!index) return "";
+  const words2 = [];
+  for (const [w, ps] of Object.entries(index)) for (const p of ps) words2[p] = w;
+  return words2.filter((w) => w !== void 0).join(" ").replace(/\s+([.,;:!?)])/g, "$1").replace(/\(\s+/g, "(").trim();
+}
+async function openAlexAbstract(doi) {
+  try {
+    const j = JSON.parse(await fetchText(`https://api.openalex.org/works/https://doi.org/${encodeURIComponent(doi)}?mailto=${encodeURIComponent(contactEmail())}&select=abstract_inverted_index`, { "User-Agent": LIBRARY_UA }));
+    return fromInvertedIndex(j.abstract_inverted_index);
+  } catch {
+    return "";
+  }
+}
+async function fetchCsl(doi) {
+  try {
+    const r = await fetch(`https://doi.org/${encodeURIComponent(doi)}`, { headers: { Accept: "application/vnd.citationstyles.csl+json", "User-Agent": LIBRARY_UA }, redirect: "follow", signal: AbortSignal.timeout(3e4) });
+    if (!r.ok) return null;
+    const t = await r.text();
+    return /^\s*\{/.test(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+var CSL_TYPES = { "article-journal": "Journal Article", "paper-conference": "Conference Paper", chapter: "Book Chapter", book: "Book", report: "Report", thesis: "Dissertation", "posted-content": "Preprint", article: "Preprint", dataset: "Dataset" };
+function parseCsl(json2) {
+  let m;
+  try {
+    m = JSON.parse(json2);
+  } catch {
+    return null;
+  }
+  if (!m?.DOI && !m?.title) return null;
+  const people = m.author ?? m.editor ?? [];
+  const authors = people.map((a) => a.family ? [a.family, String(a.given ?? "").split(/[\s.-]+/).filter(Boolean).map((g) => g[0]).join("")].filter(Boolean).join(" ") : a.literal ?? a.name ?? "").filter(Boolean);
+  const date = m.issued?.["date-parts"]?.[0] ?? m.published?.["date-parts"]?.[0];
+  const abs = text2(String(m.abstract ?? ""));
+  return {
+    pmid: "",
+    pmcid: null,
+    doi: String(m.DOI ?? "").toLowerCase(),
+    title: text2(String(Array.isArray(m.title) ? m.title[0] : m.title ?? "")) || String(m.DOI),
+    authors,
+    firstAuthor: people[0] ? people[0].family ?? people[0].literal ?? null : null,
+    journal: text2(String(Array.isArray(m["container-title"]) ? m["container-title"][0] ?? "" : m["container-title"] ?? "")) || m.publisher || null,
+    year: date?.[0] ? String(date[0]) : null,
+    publicationTypes: [CSL_TYPES[m.type] ?? "Other"],
+    abstract: abs ? [{ label: null, text: abs }] : [],
+    corrections: [],
+    coi: null,
+    funding: []
+  };
+}
+
+// src/tools.ts
+var pkg = (() => {
+  try {
+    return JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8"));
+  } catch {
+    return { name: "ai4l-library", version: "0.0.0" };
+  }
+})();
+var INSTRUCTIONS = `ai4l-library builds a local library of the scientific papers, drug labels and trial records cited by evidence reviews. Given an ID ("type:value": a paper pmid:30955454, bare digits count as pmid; a drug label dailymed:<set ID>; a trial record nct:05173896, the eight digits \u2014 nct:NCT05173896 and a bare NCT05173896 are accepted) it fetches the record and stores it as files under the library directory. Nothing flows through your context: the server writes to disk itself and returns only a small JSON status per call. One ID per call \u2014 no batches.
+
+Tools:
+- library_add(id) \u2014 build or complete the entry for one ID and return its status. Idempotent: a full_text entry is returned as is; an abstract entry retries only tiers whose earlier failure was transient (network, rate limit, wall page) and older than retry_after_days \u2014 permanent reasons (no PMCID, closed, no body) are never retried. An existing entry whose PubMed record was last read more than refresh_after_days ago (default 30) gets the record re-read for new correction notices and retractions; the stored abstract and full text are not touched.
+- library_status(id) \u2014 read-only: the entry's status, or level "missing".
+- library_read(id, section?, query?, max_chars?, max_hits?) \u2014 one small piece of a stored paper's Markdown, never the whole paper. No section/query: the outline (headings with word counts, and whether it is the full text or the abstract only). section: a heading from the outline (case-insensitive substring) \u2192 that section's text, capped at max_chars. query: search terms \u2192 the paragraphs containing all of them, each with its section, best first, at most max_hits; with no hit the answer lists the headings instead. Every full text converted from PMC/JATS XML has a "Declarations" section \u2014 funding, conflicts of interest, author notes \u2014 so section "Declarations" answers who paid and who declares what in one call; an empty answer there means the paper states nothing. Reads are read-only and may run in parallel.
+- library_verify(claim, id) \u2014 is one finding of a review stated by one source it cites? claim: the finding alone as a complete statement (subject, intervention, outcome, number), without its citations and without the review's framing or inference; id: one source the review cites for it \u2014 a paper, a drug label (dailymed:\u2026) or a trial record (nct:\u2026), each judged on its stored full text the same way. A finding cited to three papers is three calls with the same claim; a claim that names a source, joins two findings or is a fragment is refused. The server reads the paper (full text, else abstract) and asks a decision model; nothing of the paper enters your context. Result: verdict "pass" (score is the probability), "fail" (the full text does not state it), "na" (only the abstract is in the library and does not state it, or only the title) or "error" (claim empty, too short, a fragment, naming a source or compound; paper not in the library; no model; model failure); basis full_text, abstract or title; glyphs_unresolved, the symbols the paper's PDF font gave no character for (above 0: a fail may be the font, not the paper); superseded, true when the claim uses a figure a stored correction replaced (the verdict is kept), null without a stored correction. Call library_add on the paper first.
+- library_info(ids?) \u2014 library-wide, everything the TUI shows: the library directory, the decision model and whether it answers, entries and size on disk, per type (pmid, doi, dailymed, nct) the entries with their levels (full_text, abstract, title) and retractions; entry counts by type and level, counts of retracted and not-citable entries and of entries with errata, expressions of concern and updates, the configured tiers (enabled/disabled, in order), the verify model with its endpoint and whether it answers right now (ok, ms, error); ids=true lists every entry ID.
+- get_version() \u2014 package name, version and the resolved library directory.
+
+Every action is appended to <library>/library.log, one line per action, prefixed with the host the server runs on.
+
+Status JSON fields: requested, type, id, entry, entry_dir, library_dir, pmid, setid (a drug label's DailyMed set ID), nctid (a trial record's ClinicalTrials.gov ID), publications (a trial record's results publications, pmid:\u2026), pmcid, doi, title, first_author, year, publication_types, retracted, corrections, coi (the paper's conflict-of-interest statement: PubMed's, else the paper's own from its full text; null when neither states one), funding (who paid: PubMed's grant agencies, else the paper's own funding statement; [] when neither states any), citable, comment, has_abstract (false for title-only records: letters, editorials, old papers \u2014 not citable evidence unless a full text was retrieved), level (what the entry holds: "full_text", "abstract", or "title" when there is neither a full text nor abstract text; "missing" from library_status when there is no entry), version, retrieved_by, retrieved_date, pubmed_checked, attempts, files, glyphs_unresolved (control characters left in the full text where a PDF font gave no symbol \u2014 a minus, \xB1, \u2264 \u2014 so a figure there may not match; null without full text), and error when the call could not produce an entry ("invalid id", "type not supported yet", "pmid not found", or a fetch failure).
+
+citable is the one flag to check before citing a paper as evidence: false when PubMed records it as retracted (later also when a correction changed its data). comment says why, or \u2014 when citable \u2014 names what to be aware of: an erratum (not assessed; read it via library_add on its pmid when it has one), an expression of concern, or a newer version that supersedes this one (cite that instead). corrections lists the notices behind it, {type, pmid, source}: type is erratum_in, retraction_in, partial_retraction_in, retracted_and_republished_in, expression_of_concern_in or update_in; pmid is the notice's own PMID (null when PubMed has none); source its citation. Notices are read from PubMed at ingest and re-read once the record is older than refresh_after_days (pubmed_checked); the stored abstract and full text are never altered by a notice.
+
+v0.2: pmid:, doi:, dailymed: and nct: IDs (other types return error "type not supported yet"). A paper PubMed does not index \u2014 doi:10.\u2026, from the review's doi.org link \u2014 gets its record from Crossref: title, authors, journal, year, the abstract (Crossref's, else OpenAlex's), funders, and Crossref's update notices (corrections, retractions) as corrections; status pmid null, the head line says "not in PubMed"; the full-text cascade then runs on the DOI (unpaywall, openalex, tdm, core, url tiers). library_add on a DOI PubMed does index builds that paper's pmid: entry and stores a copy of it under doi:, so the DOI resolves on disk: library_status, library_read and library_verify answer from the doi: entry without any lookup; the copy is refreshed from the pmid: entry on every library_add of the DOI. A trial record \u2014 nct:<8 digits>, from the review's ClinicalTrials.gov link \u2014 is fetched from the ClinicalTrials.gov API as the current record and stored as a full text: one section per module (identification with secondary IDs, status with every date and its actual/estimated type, sponsor and collaborators, description, conditions, design with phase, allocation, masking and the enrollment with its type, arms and interventions with doses, primary and secondary outcomes with time frames, eligibility, locations, references) and, when results are posted, the participant flow, baseline, every outcome measure with its group values and the adverse events as tables. Values are in plain words: "Phase 2", "Active, not recruiting", "100 (estimated)". Its status has nctid, publications (the results publications as pmid:\u2026 from the record's references), title the brief title, first_author the lead sponsor, year the first-posted year, version the last-update-posted date, publication_types ["Trial Registration"]; library_read and library_verify work on it like on a paper. An entry older than refresh_after_days is re-fetched and rewritten when the record was updated since \u2014 a stale status in a review then fails, which is right. The entry holds the API JSON and the Markdown as nct-<digits>-fulltext.json and -fulltext.md under nct/<digits 1\u20132>/<digits 1\u20134>/<digits>/; its log line names the update date and the status. A drug label \u2014 dailymed:<set ID>, the set ID being the fixed identifier in the label's DailyMed URL (\u2026/drugInfo.cfm?setid=<set ID>) \u2014 is fetched from DailyMed as the current version of the FDA prescribing information and stored as a full text: a "Highlights" section with the header lines (product line, "Initial U.S. Approval: <year>"), then every text section in order, the boxed warning and recent major changes named as such (indications, dosage, contraindications, warnings, adverse reactions with their tables, drug interactions, clinical pharmacology, clinical studies), no abstract. Its status has setid, title "<brand> (<generic>) <form> \u2014 prescribing information", first_author the labeler, year the effective year, version "spl <n>", publication_types ["Drug Label"]; library_read and library_verify work on it like on a paper. An entry older than refresh_after_days is re-fetched, and rewritten when the label's version changed. The entry holds the SPL XML and the Markdown as dailymed-<set ID>-fulltext.xml and -fulltext.md under dailymed/<first 2>/<first 4>/<set ID>/; its log line names the version and effective date. Tiers: pubmed (metadata + abstract, always), then the full-text cascade: inbox (a file you downloaded yourself, dropped into <library>/inbox/ with the PMID in its name: PDF, XML or HTML), pmc (JATS XML), europepmc (Europe PMC: its own XML/PDF and the free links it lists), tdm (the publishers' text-and-data-mining links from Crossref, with ELSEVIER_API_KEY / WILEY_TDM_TOKEN), unpaywall and openalex (locate open-access copies and download them: PDF, XML or HTML \u2192 Markdown), core (CORE repository copies, with CORE_API_KEY), plus user url tiers (a URL template with {doi}/{pmid}/{pmcid}, e.g. an institutional proxy) from <library>/config.json. Each result is checked (title present, methods and results present, no wall page) before it counts. Level "full_text" when a tier succeeded, else "abstract" with the failed tiers in attempts.`;
+var idSchema = z.string().describe('ID as "type:value": a paper "pmid:30955454" (bare digits count as pmid) or "doi:10.5812/asjsm.110753" (a paper PubMed does not index; a DOI PubMed indexes is taken as its PMID), a drug label "dailymed:<set ID>" (the set ID from its DailyMed page URL), or a trial record "nct:05173896" (the eight digits; nct:NCT05173896 and a bare NCT05173896 are accepted).');
+var levelWord = (m) => m.level === "abstract" && !m.has_abstract ? "title" : m.level;
+var json = (s) => ({ content: [{ type: "text", text: JSON.stringify(s, null, 2) }] });
+function noticeTag(m) {
+  const n = (t) => m.corrections.filter((c) => c.type === t).length;
+  const parts = [
+    m.retracted ? "retracted" : "",
+    n("erratum_in") ? `erratum=${n("erratum_in")}` : "",
+    n("expression_of_concern_in") ? `concern=${n("expression_of_concern_in")}` : "",
+    n("update_in") ? `update=${n("update_in")}` : ""
+  ].filter(Boolean);
+  return parts.length ? " " + parts.join(" ") : "";
+}
+function registerTools(server2) {
+  async function completeFulltext(paths, meta, requested) {
+    const paper = { title: meta.title, pmid: meta.pmid, pmcid: meta.pmcid, doi: meta.doi, headLine: readHeadLine(paths) };
+    const tried = /* @__PURE__ */ new Set();
+    let ran = false;
+    const { hit } = await fulltextCascade(paper, meta.attempts, (e) => {
+      if (e.ok === "try") tried.add(e.tier);
+      if (e.ok === false && e.ephemeral) return;
+      ran = true;
+      if (e.ok === false) meta = recordAttempts(paths, meta, [attemptLabel(e)]);
+      log(
+        "library_add",
+        requested,
+        e.ok === true ? `tier ${e.tier} ok (${e.format}, ${e.version})` : e.ok === "try" ? `tier ${e.tier} ${e.message}` : e.skipped ? `tier ${e.tier} skipped: ${e.reason}` : tried.has(e.tier) ? `tier ${e.tier} failed` : `tier ${e.tier} failed: ${e.reason}`
+      );
+    });
+    if (hit) meta = applyFulltext(paths, meta, hit, `${pkg.name} ${pkg.version}`);
+    return { meta, ran };
+  }
+  async function addLabel(requested, setid, paths, status) {
+    if (entryExists(paths)) {
+      const meta = readMeta(paths);
+      if (daysSince(meta.pubmed_checked) < settings().refresh_after_days) {
+        log("library_add", requested, `exists level=full_text retrieved_by=dailymed ${meta.version ?? ""} ${meta.year ?? ""}`);
+        return statusFromMeta(paths, meta, status);
+      }
+      try {
+        const xml = await fetchSpl(setid);
+        const s = parseSpl(xml);
+        if (!s) throw new Error("dailymed: not an SPL document");
+        const version = s.version ? `spl ${s.version}` : null;
+        if (version === meta.version) {
+          const next2 = { ...meta, pubmed_checked: today() };
+          writeMeta(paths, next2);
+          log("library_add", requested, `exists level=full_text retrieved_by=dailymed ${meta.version ?? ""} checked`);
+          return statusFromMeta(paths, next2, status);
+        }
+        const next = writeLabelEntry(paths, s, xml, `${pkg.name} ${pkg.version}`);
+        log("library_add", requested, `refreshed level=full_text retrieved_by=dailymed ${meta.version ?? "?"} \u2192 ${next.version} effective=${s.effective}`);
+        return statusFromMeta(paths, next, status);
+      } catch (e) {
+        log("library_add", requested, `refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+        return statusFromMeta(paths, meta, status);
+      }
+    }
+    try {
+      const xml = await fetchSpl(setid);
+      const s = parseSpl(xml);
+      if (!s) {
+        log("library_add", requested, "dailymed failed: not an SPL document");
+        return { ...status, error: "dailymed: not an SPL document" };
+      }
+      const meta = writeLabelEntry(paths, s, xml, `${pkg.name} ${pkg.version}`);
+      log("library_add", requested, `dailymed fetched level=full_text ${meta.version ?? ""} effective=${s.effective} ${s.brand ?? ""} (${s.generic ?? ""}) entry=${paths.entry}`);
+      return statusFromMeta(paths, meta, status);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      log("library_add", requested, `dailymed failed: ${msg}`);
+      return { ...status, error: msg };
+    }
+  }
+  async function addStudy(requested, nctid, paths, status) {
+    if (entryExists(paths)) {
+      const meta = readMeta(paths);
+      if (daysSince(meta.pubmed_checked) < settings().refresh_after_days) {
+        log("library_add", requested, `exists level=full_text retrieved_by=ctgov updated ${meta.version ?? ""}`);
+        return statusFromMeta(paths, meta, status);
+      }
+      try {
+        const json2 = await fetchStudy(nctid);
+        const s = parseStudy(json2);
+        if (!s) throw new Error("ctgov: not a study record");
+        if (s.lastUpdate === meta.version) {
+          const next2 = { ...meta, pubmed_checked: today() };
+          writeMeta(paths, next2);
+          log("library_add", requested, `exists level=full_text retrieved_by=ctgov updated ${meta.version ?? ""} checked`);
+          return statusFromMeta(paths, next2, status);
+        }
+        const next = writeStudyEntry(paths, s, json2, `${pkg.name} ${pkg.version}`);
+        log("library_add", requested, `refreshed level=full_text retrieved_by=ctgov updated ${meta.version ?? "?"} \u2192 ${next.version} ${s.status ?? ""}${s.hasResults ? " results" : ""}`);
+        return statusFromMeta(paths, next, status);
+      } catch (e) {
+        log("library_add", requested, `refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+        return statusFromMeta(paths, meta, status);
+      }
+    }
+    try {
+      const json2 = await fetchStudy(nctid);
+      const s = parseStudy(json2);
+      if (!s) {
+        log("library_add", requested, "ctgov failed: not a study record");
+        return { ...status, error: "ctgov: not a study record" };
+      }
+      const meta = writeStudyEntry(paths, s, json2, `${pkg.name} ${pkg.version}`);
+      log("library_add", requested, `ctgov fetched level=full_text updated ${meta.version ?? ""} ${s.status ?? ""}${s.hasResults ? " results" : ""} ${s.acronym ?? ""} entry=${paths.entry}`);
+      return statusFromMeta(paths, meta, status);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      log("library_add", requested, `ctgov failed: ${msg}`);
+      return { ...status, error: msg };
+    }
+  }
+  server2.tool(
+    "library_add",
+    "Build or complete the library entry for one ID and return its status JSON. A drug label (dailymed:<set ID>) is fetched from DailyMed as the current prescribing information, a trial record (nct:<8 digits>, the NCT number's digits; nct:NCT\u2026 and a bare NCT\u2026 are accepted) from ClinicalTrials.gov as the current record with its posted results; both stored as a full text. A paper is a PMID, or a DOI (doi:10.\u2026): a DOI PubMed indexes is added as its PMID's entry plus a copy under doi: (refreshed on every add of the DOI), one PubMed does not index gets its metadata, funders and update notices from Crossref and its abstract from Crossref, else OpenAlex. For a paper, pubmed gives metadata, abstract and the correction notices (errata, retractions, expressions of concern, updates \u2192 citable, comment, corrections); the full-text cascade (pmc, tdm, unpaywall, openalex, user url tiers) is then tried. Idempotent: a full_text entry is returned as is; an abstract entry retries only tiers whose earlier failure was transient and past the cooldown. An entry whose PubMed record is older than refresh_after_days gets the record re-read for new notices; abstract and full text are never touched.",
+    { id: idSchema },
+    async ({ id }) => {
+      const t0 = Date.now();
+      let parsed = parseId(id);
+      if (parsed.error) {
+        log("library_add", parsed.requested, `error ${parsed.error}`);
+        return json({ ...emptyStatus(parsed.requested, parsed.type, parsed.id, AI4L_LIBRARY_DIR), error: parsed.error });
+      }
+      let copyTo = null;
+      if (parsed.type === "doi") {
+        const doiPaths = entryPaths(AI4L_LIBRARY_DIR, "doi", parsed.id);
+        let pmid = entryExists(doiPaths) ? readMeta(doiPaths).pmid || null : null;
+        if (!pmid && !entryExists(doiPaths)) {
+          try {
+            pmid = await pmidForDoi(parsed.id);
+          } catch (e) {
+            log("library_add", parsed.requested, `pubmed lookup failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+          if (pmid && !entryExists(entryPaths(AI4L_LIBRARY_DIR, "pmid", pmid))) {
+            try {
+              if (!parsePubmedXml(await fetchPubmedXml(pmid))) {
+                log("library_add", parsed.requested, `pmid:${pmid} has no readable PubMed record \u2014 kept as doi:`);
+                pmid = null;
+              }
+            } catch {
+            }
+          }
+          if (pmid) log("library_add", parsed.requested, `indexed in PubMed as pmid:${pmid}`);
+        }
+        if (pmid) {
+          copyTo = doiPaths;
+          parsed = { requested: parsed.requested, type: "pmid", id: pmid };
+        }
+      }
+      const status = emptyStatus(parsed.requested, parsed.type, parsed.id, AI4L_LIBRARY_DIR);
+      const isDoi = parsed.type === "doi";
+      const paths = entryPaths(AI4L_LIBRARY_DIR, parsed.type, parsed.id);
+      const finish = (m) => {
+        if (!copyTo) return json(statusFromMeta(paths, m, status));
+        const copy = copyEntry(paths, copyTo);
+        return json(statusFromMeta(copyTo, copy, emptyStatus(parsed.requested, "doi", parseId(parsed.requested).id, AI4L_LIBRARY_DIR)));
+      };
+      if (parsed.type === "dailymed") return json(await addLabel(`dailymed:${parsed.id}`, parsed.id, paths, status));
+      if (parsed.type === "nct") return json(await addStudy(`nct:${parsed.id}`, `NCT${parsed.id}`, paths, status));
+      let meta, ran = false;
+      const entryExistedBefore = entryExists(paths);
+      if (entryExistedBefore) {
+        meta = readMeta(paths);
+        if (isDoi && daysSince(meta.pubmed_checked) >= settings().refresh_after_days) {
+          try {
+            const r = parseCrossref(await fetchCrossref(parsed.id) ?? "");
+            if (r) {
+              const before = noticeTag(meta);
+              meta = { ...meta, corrections: r.corrections, retracted: r.corrections.some(isRetractionNotice), funding: meta.funding.length ? meta.funding : r.funding, pubmed_checked: today() };
+              writeMeta(paths, meta);
+              log("library_add", parsed.requested, `refreshed crossref${noticeTag(meta) !== before ? ` changed: ${before.trim() || "none"} \u2192 ${noticeTag(meta).trim() || "none"}` : ""}`);
+            } else log("library_add", parsed.requested, "refresh failed: doi not found");
+          } catch (e) {
+            log("library_add", parsed.requested, `refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        } else if (daysSince(meta.pubmed_checked) >= settings().refresh_after_days) {
+          try {
+            const xml = await fetchPubmedXml(parsed.id);
+            const record = parsePubmedXml(xml);
+            if (record) {
+              const before = noticeTag(meta);
+              meta = refreshRecord(paths, meta, record, xml);
+              log("library_add", parsed.requested, `refreshed pubmed_checked=${meta.pubmed_checked}${noticeTag(meta) !== before ? ` changed: ${before.trim() || "none"} \u2192 ${noticeTag(meta).trim() || "none"}` : ""}`);
+            } else log("library_add", parsed.requested, "refresh failed: pmid not found");
+          } catch (e) {
+            log("library_add", parsed.requested, `refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+        if (meta.level === "full_text") {
+          log("library_add", parsed.requested, `exists level=full_text retrieved_by=${meta.retrieved_by}${noticeTag(meta)} ${meta.doi ? `doi:${meta.doi}` : "no-doi"}`);
+          return finish(meta);
+        }
+        log("library_add", parsed.requested, `exists level=${levelWord(meta)}${noticeTag(meta)} ${meta.doi ? `doi:${meta.doi}` : "no-doi"}`);
+      } else if (isDoi) {
+        let json_;
+        try {
+          json_ = await fetchCrossref(parsed.id);
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          log("library_add", parsed.requested, `crossref failed: ${msg}`);
+          return json({ ...status, error: msg });
+        }
+        let record = json_ ? parseCrossref(json_) : null;
+        let recordFrom = "crossref";
+        if (!record) {
+          const csl = await fetchCsl(parsed.id);
+          record = csl ? parseCsl(csl) : null;
+          if (record) {
+            json_ = csl;
+            recordFrom = "doi.org";
+          }
+        }
+        if (!record) {
+          log("library_add", parsed.requested, "crossref failed: doi not found at Crossref or doi.org");
+          return json({ ...status, error: "doi not found" });
+        }
+        if (!record.doi) record.doi = parsed.id;
+        let abstractFrom = recordFrom;
+        if (!record.abstract.length) {
+          const t = await openAlexAbstract(parsed.id);
+          if (t) {
+            record.abstract = [{ label: null, text: t }];
+            abstractFrom = "openalex";
+          }
+        }
+        meta = writeDoiEntry(paths, record, json_, `${pkg.name} ${pkg.version}`, abstractFrom, recordFrom);
+        log("library_add", parsed.requested, `${recordFrom === "crossref" ? "crossref" : "doi.org"} fetched level=${levelWord(meta)} \u2014 not in PubMed${noticeTag(meta)}${meta.has_abstract ? ` abstract from ${abstractFrom}` : ""} entry=${paths.entry}`);
+      } else {
+        let xml;
+        try {
+          xml = await fetchPubmedXml(parsed.id);
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          log("library_add", parsed.requested, `pubmed failed: ${msg}`);
+          return json({ ...status, error: msg });
+        }
+        const record = parsePubmedXml(xml);
+        if (!record) {
+          log("library_add", parsed.requested, "pubmed failed: pmid not found");
+          return json({ ...status, error: "pmid not found" });
+        }
+        meta = writeEntry(paths, record, xml, `${pkg.name} ${pkg.version}`);
+        log("library_add", parsed.requested, `pubmed fetched level=${levelWord(meta)}${noticeTag(meta)} ${meta.doi ? `doi:${meta.doi}` : "no-doi"}${meta.pmcid ? ` pmcid:${meta.pmcid}` : ""} entry=${paths.entry}`);
+      }
+      ({ meta, ran } = await completeFulltext(paths, meta, parsed.requested));
+      if (entryExistedBefore && !ran) return finish(meta);
+      const secs = `${((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0")}s`;
+      log("library_add", parsed.requested, `done ${secs} level=${levelWord(meta)} retrieved_by=${meta.retrieved_by}`);
+      return finish(meta);
+    }
+  );
+  server2.tool(
+    "library_status",
+    'Read-only status of the library entry for one paper ID: the same status JSON as library_add, or level "missing" when there is no entry. Never fetches.',
+    { id: idSchema },
+    async ({ id }) => {
+      const parsed = parseId(id);
+      const status = emptyStatus(parsed.requested, parsed.type, parsed.id, AI4L_LIBRARY_DIR);
+      if (parsed.error) {
+        log("library_status", parsed.requested, `error ${parsed.error}`);
+        return json({ ...status, error: parsed.error });
+      }
+      const paths = entryPaths(AI4L_LIBRARY_DIR, parsed.type, parsed.id);
+      if (entryExists(paths)) {
+        const s = readStatus(paths, status);
+        log("library_status", parsed.requested, `level=${s.level}`);
+        return json(s);
+      }
+      log("library_status", parsed.requested, "level=missing");
+      return json({ ...status, entry: paths.entry, entry_dir: paths.entryDir, level: "missing" });
+    }
+  );
+  server2.tool(
+    "library_read",
+    `Read one small piece of a stored paper's Markdown \u2014 never the whole paper. Without section/query: the outline (headings with word counts; says whether the full text or only the abstract is stored). section: a heading from the outline (case-insensitive substring, e.g. "results") \u2192 that section's text, capped at max_chars (default 6000). query: search terms \u2192 paragraphs containing all terms, each with its section, best first, at most max_hits (default 5); with no hit, the headings. Full texts converted from JATS XML have a "Declarations" section \u2014 funding, conflicts of interest, author notes \u2014 so section "Declarations" answers who paid and who declares what in one call; a paper without that section states nothing. For abstract-only entries the status carries coi and funding from PubMed. Call without section/query first, then pick. Reads may run in parallel.`,
+    {
+      id: idSchema,
+      section: z.string().optional().describe("Heading from the outline (case-insensitive substring)."),
+      query: z.string().optional().describe("Search terms; paragraphs containing all of them are returned."),
+      max_chars: z.number().int().positive().optional().describe("Cap for section text (default 6000)."),
+      max_hits: z.number().int().positive().optional().describe("Cap for query passages (default 5).")
+    },
+    async ({ id, section: section2, query, max_chars, max_hits }) => {
+      const parsed = parseId(id);
+      const out = (o2) => ({ content: [{ type: "text", text: JSON.stringify(o2, null, 2) }] });
+      if (parsed.error) {
+        log("library_read", parsed.requested, `error ${parsed.error}`);
+        return out({ requested: parsed.requested, error: parsed.error });
+      }
+      const paths = entryPaths(AI4L_LIBRARY_DIR, parsed.type, parsed.id);
+      if (!entryExists(paths)) {
+        log("library_read", parsed.requested, "error missing");
+        return out({ requested: parsed.requested, entry: paths.entry, error: "missing \u2014 call library_add first" });
+      }
+      const full = existsSync10(paths.fulltextMd);
+      const md = readFileSync9(full ? paths.fulltextMd : paths.md, "utf8");
+      const text3 = full ? "full_text" : "abstract";
+      const base = { requested: parsed.requested, entry: paths.entry, text: text3 };
+      if (section2) {
+        const sec = readSection(md, section2, max_chars ?? 6e3);
+        log("library_read", parsed.requested, `section "${section2}" ${sec ? `\u2192 "${sec.heading}" ${sec.words} words${sec.truncated ? " truncated" : ""}` : "not found"}`);
+        if (!sec) return out({ ...base, error: `no section matching "${section2}"`, outline: outline(md, text3).sections });
+        return out({ ...base, ...sec });
+      }
+      if (query) {
+        const passages = search(md, query, max_hits ?? 5);
+        log("library_read", parsed.requested, `query "${query}" \u2192 ${passages.length} passages`);
+        if (!passages.length) return out({ ...base, query, passages, sections: outline(md, text3).sections.map((s) => s.heading) });
+        return out({ ...base, query, passages });
+      }
+      const o = outline(md, text3);
+      log("library_read", parsed.requested, `outline ${o.sections.length} sections ${o.words} words`);
+      return out({ ...base, ...o });
+    }
+  );
+  server2.tool(
+    "library_verify",
+    `Is one finding of a review stated by one source it cites \u2014 a paper, a drug label (dailymed:\u2026) or a trial record (nct:\u2026)? claim: the finding alone, verbatim from the review, without its citations ("IPSS fell 2.3 points more than placebo in men with ED"); id: one of the papers the review cites for it, which must be in the library (library_add first). A finding cited to three papers is three calls with the same claim. Build the claim as a complete statement: subject, intervention, outcome, number \u2014 when splitting a sentence leaves a fragment, restore the subject from the sentence; cut what the review adds around the finding (where it was published, who funded it, "in two trials", "pooled data", the review's own inference or advice after "so"); one number set per claim, so split at semicolons too. Statements about the literature as a whole ("no trial has tested"), recommendations and history are not claims. A claim that names a source, joins two findings, or is a fragment is refused. The server reads the paper and asks a decision model; nothing of the paper enters your context. verdict: "pass" (the paper states it; score is the probability), "fail" (its full text was read and does not state it), "na" (only its abstract is in the library and that does not state it, or only its title), or "error" (claim empty, too short, a fragment, naming a source or compound; paper not in the library; no model configured; model failure). basis: full_text, abstract or title. glyphs_unresolved: symbols the paper's PDF font gave no character for (a minus, \xB1, \u2264 \u2026) \u2014 when above 0, a fail may be the font, not the paper. superseded: true when the paper carries a stored correction ("Corrected in PubMed abstract") and the claim uses a figure that correction replaced; the verdict is kept, the figure is out of date; null for a paper without a stored correction.`,
+    {
+      claim: z.string().describe("One finding, verbatim from the review, without its citations."),
+      id: idSchema
+    },
+    async ({ claim, id }) => {
+      const t0 = Date.now();
+      const cfg = verifyConfig();
+      const r = await verifyClaim(claim, id, cfg, cfg ? decider(cfg) : null);
+      const secs = `${((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0")}s`;
+      log("library_verify", r.id, r.error ? `${secs} verdict=${"error".padEnd(5)} ${r.error} | ${claim}` : `${secs} verdict=${r.verdict.padEnd(5)} basis=${r.basis.padEnd(9)} score=${r.score === null ? "-    " : r.score.toFixed(3)}${r.windows > 1 ? ` windows=${r.windows}` : ""}${r.superseded ? " superseded" : ""}${r.glyphs_unresolved ? ` glyphs=${r.glyphs_unresolved}` : ""} | ${claim}`);
+      return { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "library_info",
+    "Library-wide summary \u2014 everything the TUI shows: the library directory and host; the decision model with its endpoint and whether it answers; the entry count and the size on disk (size, size_bytes); per entry type (types) the entries and their levels (full_text, abstract, title) and retractions; entry counts by type and level, counts of retracted and not-citable entries and of entries with errata, expressions of concern and updates, the configured retrieval tiers (enabled/disabled, in order, and where that configuration came from), the decision model behind library_verify (model, endpoint, whether it runs on this machine, and whether it answers right now: ok with the answer time, or the error), the library directory and host. ids=true also lists every entry ID.",
+    { ids: z.boolean().optional().describe("Also list every entry ID (type:value).") },
+    async ({ ids }) => {
+      const info = libraryInfo(AI4L_LIBRARY_DIR, HOST, ids === true);
+      const cfg = verifyConfig();
+      if (info.verify && cfg) {
+        const t0 = Date.now();
+        try {
+          const a = await decider(cfg)("The sky is blue.", { q: { type: "noul", instructions: "Is the sky blue?" } });
+          info.verify = { ...info.verify, ok: typeof a.q?.noul === "number", ms: Date.now() - t0, error: null };
+        } catch (e) {
+          info.verify = { ...info.verify, ok: false, ms: Date.now() - t0, error: e instanceof Error ? e.message : String(e) };
+        }
+      }
+      log("library_info", null, `entries=${info.entries}${info.verify ? ` verify ${info.verify.model} ${info.verify.ok ? `ok ${info.verify.ms} ms` : `down: ${info.verify.error}`}` : " verify not configured"}`);
+      return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "get_version",
+    "Get the running ai4l-library MCP server's package name and version, and the resolved library directory. Useful to confirm which build is loaded.",
+    {},
+    async () => {
+      log("get_version", null, `${pkg.name} ${pkg.version}`);
+      return { content: [{ type: "text", text: `${pkg.name} v${pkg.version} \xB7 host: ${HOST} \xB7 library_dir: ${AI4L_LIBRARY_DIR} \xB7 log: ${LOG_FILE}` }] };
     }
-  );
-  server2.tool(
-    "get_version",
-    "Get the running ai4l-library MCP server's package name and version, and the resolved library directory. Useful to confirm which build is loaded.",
-    {},
-    async () => ({ content: [{ type: "text", text: `${pkg.name} v${pkg.version} \xB7 library_dir: ${LIBRARY_DIR}` }] })
   );
 }
 
 // src/index.ts
+loadDotenv();
 var server = new McpServer(
   { name: pkg.name, version: pkg.version },
   { instructions: INSTRUCTIONS }