fh-library-dev 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,4063 @@
+#!/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.FH_LIBRARY_ENV?.trim();
+  if (named) return named;
+  if (existsSync(resolve(".env"))) return resolve(".env");
+  const lib = env.FH_LIBRARY_DIR?.trim() || (existsSync("/library") ? "/library" : "library");
+  return join(resolve(lib), ".env");
+}
+var loadedFromDotenv = /* @__PURE__ */ new Set();
+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]);
+      loadedFromDotenv.add(m[1]);
+    }
+  }
+  return loaded;
+}
+function sourceOf(name, env = process.env) {
+  if (!env[name]?.trim()) return "default";
+  return loadedFromDotenv.has(name) ? ".env" : "environment";
+}
+var str = (name, env = process.env) => env[name]?.trim() ?? "";
+function num(name, def, env = process.env, ok = (n) => n >= 0) {
+  const v = str(name, env);
+  if (!v) return def;
+  const n = Number(v);
+  return Number.isFinite(n) && ok(n) ? n : def;
+}
+function bool(name, def, env = process.env) {
+  const v = str(name, env).toLowerCase();
+  return ["true", "1", "yes", "on"].includes(v) ? true : ["false", "0", "no", "off"].includes(v) ? false : def;
+}
+
+// src/env-load.ts
+loadDotenv();
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/contact.ts
+var DEFAULT = "hello@forever-healthy.org";
+var contactEmail = (env = process.env) => str("FH_LIBRARY_CONTACT_EMAIL", env) || 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 = `fh-library (+https://github.com/forever-healthy/FH-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/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 } from "fast-xml-parser";
+var parser = new XMLParser({
+  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 SKIP_INLINE = /* @__PURE__ */ new Set(["inline-graphic", "graphic", "private-char"]);
+function formula(n) {
+  const all = [n, ...descendants(n)];
+  const tex = all.find((x) => tagOf(x) === "tex-math");
+  if (tex) {
+    let t = plainText(kids(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(tagOf(x)));
+  return mml ? plainText(kids(mml)).replace(/\s+/g, "") : plainText(kids(n));
+}
+function descendants(n) {
+  if ("#text" in n) return [];
+  const out = [];
+  for (const k of kids(n)) {
+    out.push(k, ...descendants(k));
+  }
+  return out;
+}
+var wrap = (mark, s) => {
+  const m = /^(\s*)([\s\S]*?)(\s*)$/.exec(s);
+  return m[2] ? `${m[1]}${mark}${m[2]}${mark}${m[3]}` : m[1] + m[3];
+};
+function inlineText(nodes) {
+  let out = "";
+  for (const n of nodes) {
+    if ("#text" in n) {
+      out += String(n["#text"]);
+      continue;
+    }
+    const t = tagOf(n);
+    if (SKIP_INLINE.has(t)) continue;
+    const inner = () => inlineText(kids(n));
+    switch (t) {
+      case "italic":
+      case "i":
+        out += `*${inner()}*`;
+        break;
+      case "bold":
+      case "b":
+        out += `**${inner()}**`;
+        break;
+      case "sup":
+        out += wrap("^", inner());
+        break;
+      case "sub":
+        out += wrap("~", inner());
+        break;
+      case "break":
+        out += " ";
+        break;
+      case "ext-link":
+      case "uri": {
+        const href = attr(n, "xlink:href") || attr(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(kids(n));
+  return out;
+}
+var squash = (s) => s.replace(/\s+/g, " ").trim();
+var cell = (s) => squash(s).replace(/\|/g, "\\|");
+function renderTable(table3) {
+  const rows = [];
+  const walk = (nodes) => {
+    for (const n of nodes) {
+      const t = tagOf(n);
+      if (t === "tr") rows.push(kids(n).filter((c) => ["td", "th"].includes(tagOf(c))).map((c) => cell(inlineText(kids(c)))));
+      else if (!("#text" in n)) walk(kids(n));
+    }
+  };
+  walk(kids(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 ? squash(plainText(kids(n).filter((c) => tagOf(c) === "label"))) : "";
+  const cap = kids(n).find((c) => tagOf(c) === "caption");
+  const capText = cap ? squash(inlineText(kids(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 = squash(String(n["#text"]));
+      if (t2) out.push(t2);
+      continue;
+    }
+    const t = tagOf(n);
+    const c = kids(n);
+    switch (t) {
+      case "sec":
+      case "app":
+      case "ack":
+      case "boxed-text":
+      case "notes":
+      case "glossary": {
+        const title = c.find((x) => tagOf(x) === "title");
+        if (title) out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${squash(inlineText(kids(title)))}`);
+        else if (t === "ack") out.push(`${"#".repeat(Math.min(depth + 1, 6))} Acknowledgements`);
+        out.push(...renderBlocks(c.filter((x) => tagOf(x) !== "title"), depth + 1));
+        break;
+      }
+      case "title":
+        out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${squash(inlineText(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(tagOf(x)));
+        const blocks2 = c.filter((x) => !("#text" in x) && BLOCK.has(tagOf(x)));
+        const s = squash(inlineText(inline2));
+        if (s) out.push(s);
+        out.push(...renderBlocks(blocks2, depth));
+        break;
+      }
+      case "list": {
+        const ordered = /order|alpha|roman|number/i.test(attr(n, "list-type"));
+        let i = 0;
+        for (const li of c.filter((x) => tagOf(x) === "list-item")) {
+          i++;
+          const body = renderBlocks(kids(li).filter((x) => tagOf(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) => tagOf(x) === "table")) {
+          const md = renderTable(tbl);
+          if (md) out.push(md);
+        }
+        const foot = c.find((x) => tagOf(x) === "table-wrap-foot");
+        if (foot) out.push(...renderBlocks(kids(foot), depth));
+        break;
+      }
+      case "fig": {
+        const head = labelCaption(n);
+        out.push(head || "*(figure)*");
+        break;
+      }
+      case "disp-formula": {
+        const s = squash(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) => tagOf(x) === "def-item")) {
+          const term = d["def-item"].find((x) => tagOf(x) === "term");
+          const def = d["def-item"].find((x) => tagOf(x) === "def");
+          out.push(`**${squash(inlineText(term ? kids(term) : []))}**: ${def ? renderBlocks(kids(def), depth).join(" ") : ""}`);
+        }
+        break;
+      case "ref-list": {
+        const title = c.find((x) => tagOf(x) === "title");
+        out.push(`${"#".repeat(Math.min(depth + 1, 6))} ${title ? squash(inlineText(kids(title))) : "References"}`);
+        for (const r of c.filter((x) => tagOf(x) === "ref")) {
+          const rk = kids(r);
+          const label = squash(plainText(rk.filter((x) => tagOf(x) === "label")));
+          out.push(`- ${label ? `${label} ` : ""}${renderCitation(rk.filter((x) => tagOf(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) => tagOf(x) === "citation-alternatives");
+  if (alt) return renderCitation(kids(alt));
+  const mixed = nodes.find((x) => ["mixed-citation", "citation", "nlm-citation"].includes(tagOf(x)) && !kids(x).some((y) => tagOf(y) === "person-group"));
+  if (mixed) return squash(inlineText(kids(mixed)));
+  const el = nodes.find((x) => ["element-citation", "mixed-citation", "citation", "nlm-citation"].includes(tagOf(x)));
+  if (!el) return squash(inlineText(nodes));
+  const f = kids(el);
+  const get = (tag) => f.filter((x) => tagOf(x) === tag).map((x) => squash(inlineText(kids(x))));
+  const names = f.filter((x) => tagOf(x) === "person-group").flatMap((g) => kids(g)).map((x) => {
+    const t = tagOf(x);
+    if (t === "etal") return "et al";
+    if (t === "collab") return squash(plainText(kids(x)));
+    if (t === "name" || t === "string-name") {
+      const sur = squash(plainText(kids(x).filter((y) => tagOf(y) === "surname")));
+      const giv = squash(plainText(kids(x).filter((y) => tagOf(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) => tagOf(x) === "pub-id").map((x) => `${attr(x, "pub-id-type")}:${squash(plainText(kids(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 ? findDeep(kids(meta), "funding-group") : void 0;
+  if (fg) {
+    const statements = kids(fg).filter((x) => tagOf(x) === "funding-statement").map((x) => squash(inlineText(kids(x)))).filter(Boolean);
+    const awards = kids(fg).filter((x) => tagOf(x) === "award-group").map((ag) => {
+      const src = kids(ag).filter((x) => tagOf(x) === "funding-source").map((x) => squash(plainText(kids(x)))).filter(Boolean);
+      const ids = kids(ag).filter((x) => tagOf(x) === "award-id").map((x) => squash(plainText(kids(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 ? findDeep(kids(meta), "author-notes") : void 0;
+  if (notes) fns.push(...kids(notes).filter((x) => tagOf(x) === "fn"));
+  if (back) for (const g of kids(back).filter((x) => tagOf(x) === "fn-group")) fns.push(...kids(g).filter((x) => tagOf(x) === "fn"));
+  for (const fn of fns) {
+    const text3 = renderBlocks(kids(fn).filter((x) => tagOf(x) !== "label"), 1).join(" ").trim();
+    if (!text3) continue;
+    const label = FN_LABELS[attr(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) => tagOf(x) === tag);
+    if (!hit) return void 0;
+    cur = kids(hit);
+  }
+  return hit;
+}
+function findDeep(nodes, tag) {
+  for (const n of nodes) {
+    if ("#text" in n) continue;
+    if (tagOf(n) === tag) return n;
+    const hit = findDeep(kids(n), tag);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function parseJats(xml) {
+  const doc = parser.parse(xml);
+  const article = find(doc, ["pmc-articleset", "article"]) ?? find(doc, ["article"]) ?? findDeep(doc, "article");
+  const a = article ? kids(article) : [];
+  const front = find(a, ["front"]);
+  const meta = front ? find(kids(front), ["article-meta"]) ?? front : void 0;
+  const titleNode = meta ? find(kids(meta), ["title-group", "article-title"]) ?? findDeep(kids(meta), "article-title") : void 0;
+  const abstractNode = meta ? kids(meta).find((x) => tagOf(x) === "abstract" && !attr(x, "abstract-type")) ?? findDeep(kids(meta), "abstract") : void 0;
+  const body = find(a, ["body"]);
+  const back = find(a, ["back"]);
+  return {
+    title: titleNode ? squash(inlineText(kids(titleNode))) : "",
+    abstract: abstractNode ? renderBlocks(kids(abstractNode).filter((x) => tagOf(x) !== "title"), 2) : [],
+    body: body ? renderBlocks(kids(body), 1) : [],
+    declarations: declarations(meta, back),
+    back: back ? renderBlocks(kids(back), 1) : [],
+    hasBody: !!body && kids(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/pdf.ts
+import { getDocumentProxy } from "unpdf";
+
+// 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;
+}
+
+// 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",
+  // Cochrane reviews (their back-matter headings — Sources of support, Declarations of interest — have no text layer in the PDF)
+  "objectives",
+  "search methods",
+  "selection criteria",
+  "data collection and analysis",
+  "main results",
+  "authors' conclusions",
+  "plain language summary",
+  "summary of findings",
+  "description of studies",
+  "risk of bias in included studies",
+  "effects of interventions",
+  "summary of main results",
+  "quality of the evidence",
+  "implications for practice",
+  "implications for research",
+  "data and analyses"
+];
+var squeeze = (s) => s.toLowerCase().replace(/&/g, "and").replace(/\u2019/g, "'").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 &'\u2019]*$/.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 = [];
+    }
+  };
+  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]/;
+var newLine = () => ({ text: "", x0: Infinity, x1: -Infinity, y: 0, h: 0, geo: false });
+async function extractPages(pdf) {
+  const pages = [];
+  let prev = null, closed = false;
+  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;
+    const lines = [];
+    let cur = newLine();
+    closed = false;
+    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;
+        });
+      }
+      cur.text += s;
+      if (it.transform && it.transform.length >= 6 && s.trim()) {
+        const x = it.transform[4], w = it.width ?? 0;
+        if (!cur.geo) {
+          cur.y = it.transform[5];
+          cur.geo = true;
+        }
+        cur.x0 = Math.min(cur.x0, x);
+        cur.x1 = Math.max(cur.x1, x + w);
+        cur.h = Math.max(cur.h, it.height ?? 0);
+      }
+      if (it.hasEOL) {
+        let t = cur.text, k = t.length;
+        while (k > 0 && (t[k - 1] === " " || t[k - 1] === "	")) k--;
+        if (k >= 2 && t[k - 1] === "-" && /[A-Za-z]/.test(t[k - 2])) t = t.slice(0, k - 1) + BREAK + t.slice(k);
+        cur.text = t;
+        lines.push(cur);
+        cur = newLine();
+        closed = true;
+      } else closed = false;
+    }
+    if (cur.text) lines.push(cur);
+    if (!lines.length) continue;
+    pages.push((prev && breakBefore(prev, lines[0], columns(lines, page.view?.[2]), page.view?.[2]) ? "\n" : "") + joinLines(lines, prev, page.view?.[2]));
+    prev = lines[lines.length - 1];
+  }
+  return dehyphenate((pages.join("\n") + (closed ? "\n" : "")).replace(/[^\S\n]+/g, " ").replace(/ ?\n ?/g, "\n").replace(/\n{3,}/g, "\n\n"));
+}
+function columns(lines, pageWidth) {
+  const geo = lines.filter((l) => l.geo);
+  const width = pageWidth ?? Math.max(0, ...geo.map((l) => l.x1));
+  return [0, 1].map((c) => {
+    const ls = geo.filter((l) => columnOf(l, width) === c);
+    const dys = [];
+    for (let i = 1; i < ls.length; i++) {
+      const dy = ls[i - 1].y - ls[i].y;
+      if (dy > 0 && dy < 3 * Math.max(ls[i].h, 6)) dys.push(dy);
+    }
+    return { left: percentile(ls.map((l) => l.x0), 0.05), right: rightEdge(ls.map((l) => l.x1)), pitch: percentile(dys, 0.5) };
+  });
+}
+var columnOf = (l, width) => l.x0 < width / 2 ? 0 : 1;
+function percentile(xs, q) {
+  if (!xs.length) return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.min(s.length - 1, Math.floor(q * s.length))];
+}
+function rightEdge(x1s) {
+  if (!x1s.length) return 0;
+  const bins = /* @__PURE__ */ new Map();
+  for (const x of x1s) {
+    const b = Math.round(x / 2);
+    bins.set(b, (bins.get(b) ?? 0) + 1);
+  }
+  const [bin, n] = [...bins.entries()].sort((a, b) => b[1] - a[1])[0];
+  return n >= 0.3 * x1s.length ? bin * 2 : percentile(x1s, 0.95);
+}
+function breakBefore(p, l, cols, pageWidth) {
+  if (!p.geo || !l.geo) return false;
+  const width = pageWidth ?? Math.max(p.x1, l.x1);
+  const cp = cols[columnOf(p, width)], cl = cols[columnOf(l, width)];
+  const text3 = l.text.trim(), ptext = p.text.trim();
+  if (!text3 || !ptext) return false;
+  if (/^[•▪◦●■□○·]|^[-–]\s/.test(text3)) return true;
+  if (p.h && l.h && Math.abs(l.h - p.h) > 1.5) return true;
+  const dy = p.y - l.y;
+  if (cp === cl && dy > 0 && cl.pitch && dy > 1.4 * cl.pitch && dy < 6 * cl.pitch) return true;
+  const indent = l.x0 - cl.left, pindent = p.x0 - cp.left;
+  if (indent > 3 && indent < 40 && pindent <= 3) return true;
+  const short = p.x1 < cp.right - 0.08 * (cp.right - cp.left);
+  return short && /[.!?:][)"'\]]?$/.test(ptext) && /^[A-Z0-9(["'•]/.test(text3);
+}
+function joinLines(lines, prev, pageWidth) {
+  const cols = columns(lines, pageWidth);
+  let out = lines[0].text;
+  for (let i = 1; i < lines.length; i++) out += (breakBefore(lines[i - 1], lines[i], cols, pageWidth) ? "\n\n" : "\n") + lines[i].text;
+  void prev;
+  return out;
+}
+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/browser.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { join as join3 } from "path";
+import { chromium } from "playwright-core";
+
+// src/layout.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+var FH_LIBRARY_DIR = (() => {
+  const env = process.env.FH_LIBRARY_DIR;
+  if (env && env.trim()) return resolve2(env.trim());
+  if (existsSync2("/library")) return "/library";
+  return resolve2("library");
+})();
+var doiSlug = (doi) => doi.toLowerCase().replace(/[^a-z0-9.-]+/g, "_");
+function entryDirRel(type, num2) {
+  if (type === "doi") {
+    const h = createHash("sha1").update(num2).digest("hex");
+    return `${type}/${h.slice(0, 2)}/${h.slice(0, 4)}/${num2}`;
+  }
+  if (!/^\d+$/.test(num2)) return `${type}/${num2.slice(0, 2)}/${num2.slice(0, 4)}/${num2}`;
+  const l1 = num2.length > 6 ? num2.slice(0, -6) : "0";
+  const l2 = num2.length > 4 ? num2.slice(0, -4) : "0";
+  return `${type}/${l1}/${l2}/${num2}`;
+}
+function entryPaths(libraryDir, type, num2) {
+  if (type === "doi") num2 = doiSlug(num2);
+  const entry = `${type}-${num2}`;
+  const entryDir = join2(libraryDir, entryDirRel(type, num2));
+  return {
+    entry,
+    entryDir,
+    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/browser.ts
+function browserConfig(env = process.env) {
+  const out = { browsers: [], headless: "auto" };
+  for (let i = 1; i <= 9; i++) {
+    const v = str(`FH_LIBRARY_BROWSER_${i}`, env);
+    if (v && !out.browsers.includes(v)) out.browsers.push(v);
+  }
+  const h = str("FH_LIBRARY_BROWSER_HEADLESS", env).toLowerCase();
+  if (h === "true" || h === "false") out.headless = h === "true";
+  return out;
+}
+var INSTALL_HINT = "npx playwright-core install chromium";
+var PLAYWRIGHT_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("playwright-core/package.json").version;
+  } catch {
+    return "unknown";
+  }
+})();
+var MISMATCH = "Playwright version mismatch";
+function connectError(e, endpoint) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return /\b428\b/.test(msg) ? new Error(`${MISMATCH} \u2014 server ${endpoint} must run playwright-core ${PLAYWRIGHT_VERSION}`) : e instanceof Error ? e : new Error(msg);
+}
+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 existsSync3(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 = join3(FH_LIBRARY_DIR, ".browser");
+  mkdirSync(join3(dir, "Default"), { recursive: true });
+  const prefs = join3(dir, "Default", "Preferences");
+  let p = {};
+  try {
+    p = JSON.parse(readFileSync2(prefs, "utf8"));
+  } catch {
+  }
+  p.plugins = { ...p.plugins ?? {}, always_open_pdf_externally: true };
+  p.download = { ...p.download ?? {}, prompt_for_download: false };
+  writeFileSync(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 = join3(FH_LIBRARY_DIR, ".browser");
+  mkdirSync(dir, { recursive: true });
+  return join3(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"] }) }
+        }).catch((e) => {
+          throw connectError(e, endpoint);
+        });
+        browser.on("disconnected", drop);
+        const state = stateFile(endpoint);
+        const ctx2 = await browser.newContext({ ...CONTEXT_OPTS, ...existsSync3(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: readFileSync2(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) {
+    const why = res.headers.get("x-brd-err-msg") ?? res.headers.get("x-brd-error");
+    throw new Error(`unlocker HTTP ${res.status}${why ? `: ${why}` : ""}`);
+  }
+  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 && bare(r.reason).startsWith(MISMATCH)) ctx.onAlert?.(`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 && /^unlocker HTTP/.test(bare(r.reason))) ctx.onAlert?.(`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 existsSync4, readdirSync, readFileSync as readFileSync3, unlinkSync } from "fs";
+import { join as join4 } from "path";
+var INBOX_DIR = join4(FH_LIBRARY_DIR, "inbox");
+var EXT = { ".pdf": "application/pdf", ".xml": "text/xml", ".html": "text/html", ".htm": "text/html" };
+function findInboxFile(dir, pmid) {
+  if (!existsSync4(dir)) return null;
+  const re = new RegExp(`(^|[^0-9])${pmid}([^0-9]|$)`);
+  for (const name of readdirSync(dir).sort()) {
+    const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+    if (ext in EXT && re.test(name.slice(0, -ext.length))) return join4(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 = readFileSync3(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", "fh-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, tokens2 = {}, 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 = tokens2[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(tokens2 = {}) {
+  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, tokens2);
+      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 VARIABLES = [
+  "FH_LIBRARY_DIR",
+  "FH_LIBRARY_ENV",
+  "FH_LIBRARY_TIERS",
+  "FH_LIBRARY_CONTACT_EMAIL",
+  "FH_LIBRARY_ELSEVIER_API_KEY",
+  "FH_LIBRARY_WILEY_TDM_TOKEN",
+  "FH_LIBRARY_CORE_API_KEY",
+  "FH_LIBRARY_PROXY_URL",
+  "FH_LIBRARY_PROXY_HEADERS",
+  "FH_LIBRARY_BROWSER_1",
+  "FH_LIBRARY_BROWSER_2",
+  "FH_LIBRARY_BROWSER_3",
+  "FH_LIBRARY_BROWSER_HEADLESS",
+  "FH_LIBRARY_VERIFY_URL",
+  "FH_LIBRARY_VERIFY_API_KEY",
+  "FH_LIBRARY_VERIFY_MODEL",
+  "FH_LIBRARY_VERIFY_THRESHOLD",
+  "FH_LIBRARY_VERIFY_TIMEOUT_SECS",
+  "FH_LIBRARY_RETRY_AFTER_DAYS",
+  "FH_LIBRARY_RETRY_BLOCKED",
+  "FH_LIBRARY_REFRESH_AFTER_DAYS",
+  "NCBI_API_KEY",
+  "BRIGHTDATA_API_TOKEN",
+  "BRIGHTDATA_ZONE"
+];
+var sources = (env = process.env) => Object.fromEntries(VARIABLES.map((v) => [v, sourceOf(v, env)]));
+function settings(env = process.env) {
+  return {
+    retry_after_days: num("FH_LIBRARY_RETRY_AFTER_DAYS", 1, env),
+    retry_blocked: bool("FH_LIBRARY_RETRY_BLOCKED", false, env),
+    refresh_after_days: num("FH_LIBRARY_REFRESH_AFTER_DAYS", 30, env)
+  };
+}
+function proxyHeaders(spec) {
+  const out = {};
+  for (const part of spec.split(";")) {
+    const i = part.indexOf(":");
+    if (i < 0) continue;
+    const name = part.slice(0, i).trim(), value = part.slice(i + 1).trim();
+    if (name && value) out[name] = value;
+  }
+  return out;
+}
+function resolveTiers(env = process.env) {
+  const problems = [];
+  const available = /* @__PURE__ */ new Map();
+  const tokens2 = { elsevier: str("FH_LIBRARY_ELSEVIER_API_KEY", env) || void 0, wiley: str("FH_LIBRARY_WILEY_TDM_TOKEN", env) || void 0 };
+  for (const t of BUILTIN) available.set(t.name, t.make({ tokens: tokens2, api_key: str("FH_LIBRARY_CORE_API_KEY", env) || void 0 }));
+  const proxyUrl = str("FH_LIBRARY_PROXY_URL", env);
+  if (proxyUrl) available.set("proxy", urlTier("proxy", proxyUrl, proxyHeaders(str("FH_LIBRARY_PROXY_HEADERS", env))));
+  const listed = str("FH_LIBRARY_TIERS", env);
+  const order2 = listed ? listed.split(",").map((s) => s.trim()).filter(Boolean) : [...available.keys()];
+  const tiers = [], seen = /* @__PURE__ */ new Set();
+  for (const name of order2) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const t = available.get(name);
+    if (t) tiers.push(t);
+    else if (name === "proxy") problems.push('FH_LIBRARY_TIERS: "proxy" listed, but FH_LIBRARY_PROXY_URL is unset');
+    else problems.push(`FH_LIBRARY_TIERS: unknown tier "${name}" (built-in: ${BUILTIN.map((t2) => t2.name).join(", ")}; proxy when FH_LIBRARY_PROXY_URL is set)`);
+  }
+  const all = [...tiers.map((t) => ({ name: t.name, enabled: true })), ...[...available.keys()].filter((n) => !seen.has(n)).map((name) => ({ name, enabled: false }))];
+  return { tiers, all, source: sourceOf("FH_LIBRARY_TIERS", env), problems };
+}
+
+// src/log.ts
+import { appendFileSync, mkdirSync as mkdirSync2, renameSync, statSync } from "fs";
+import { hostname } from "os";
+import { join as join5 } from "path";
+var HOST = hostname();
+var LOG_FILE = join5(FH_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 = statSync(file).size;
+  } catch {
+    return false;
+  }
+  if (size <= max) return false;
+  try {
+    renameSync(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 {
+    mkdirSync2(FH_LIBRARY_DIR, { recursive: true });
+    rotateIfLarge(LOG_FILE);
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+}
+
+// src/tools.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { z } from "zod";
+
+// src/entry.ts
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { basename, dirname } from "path";
+
+// src/pubmed.ts
+import { XMLParser as XMLParser2 } 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";
+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);
+  u.searchParams.set("tool", "fh-library");
+  u.searchParams.set("email", contactEmail());
+  return u.toString();
+}
+async function fetchPubmedXml(pmid) {
+  try {
+    return await fetchText(efetchUrl(pmid));
+  } catch (e) {
+    throw new Error(`pubmed fetch failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+var parser2 = new XMLParser2({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  parseTagValue: false,
+  processEntities: true,
+  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 inlineText2(raw) {
+  return decodeEntities(raw.replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
+}
+function decodeEntities(s) {
+  return s.replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parsePubmedXml(xml) {
+  const doc = parser2.parse(xml);
+  const article = doc?.PubmedArticleSet?.PubmedArticle?.[0];
+  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 ?? [];
+  const idOf = (t) => {
+    const hit = ids.find((i) => i["@_IdType"] === t);
+    return hit ? text(hit).trim() || null : null;
+  };
+  const authorList = art.AuthorList?.[0]?.Author ?? [];
+  const authors = authorList.map((a) => {
+    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 ? 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;
+  const abstract = (art.Abstract?.AbstractText ?? []).map((a) => ({
+    label: typeof a === "object" ? a["@_Label"] ?? null : null,
+    text: inlineText2(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: inlineText2(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: inlineText2(text(cit.CoiStatement)) || null,
+    funding,
+    pmid: text(cit.PMID).trim() || idOf("pubmed") || "",
+    pmcid: idOf("pmc"),
+    doi: idOf("doi"),
+    title: inlineText2(text(art.ArticleTitle)),
+    authors,
+    firstAuthor,
+    journal: plain(art.Journal?.Title) || null,
+    year,
+    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: inlineText2(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: inlineText2(text(d.ArticleTitle)) || inlineText2(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/spl.ts
+import { XMLParser as XMLParser3 } 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 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 squash2 = (s) => s.replace(/\s+/g, " ").trim();
+var child = (n, tag) => kids2(n).find((x) => tagOf2(x) === tag);
+function findDeep2(nodes, tag) {
+  for (const n of nodes) {
+    if ("#text" in n) continue;
+    if (tagOf2(n) === tag) return n;
+    const h = findDeep2(kids2(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 = tagOf2(n);
+    const inner = () => inline(kids2(n));
+    switch (t) {
+      case "content": {
+        const style = attr2(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 += ` (${squash2(inner())})`;
+        break;
+      case "footnoteRef":
+      case "renderMultiMedia":
+        break;
+      default:
+        out += inner();
+    }
+  }
+  return out;
+}
+function table(n) {
+  const row2 = (x) => kids2(x).filter((c) => ["td", "th"].includes(tagOf2(c))).map((c) => squash2(inline(kids2(c))).replace(/\|/g, "\\|"));
+  const collect = (nodes, into) => {
+    for (const x of nodes) {
+      if ("#text" in x) continue;
+      if (tagOf2(x) === "tr") into.push(row2(x));
+      else if (!["thead", "tfoot"].includes(tagOf2(x))) collect(kids2(x), into);
+    }
+  };
+  const head = [], body = [], foot = [];
+  for (const x of kids2(n)) {
+    const t = tagOf2(x);
+    if (t === "thead") collect(kids2(x), head);
+    else if (t === "tfoot") collect(kids2(x), foot);
+    else if (t === "tr") body.push(row2(x));
+    else if (!("#text" in x) && t !== "caption") collect(kids2(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 ? squash2(inline(kids2(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 = squash2(String(n["#text"]));
+      if (t2) out.push(t2);
+      continue;
+    }
+    const t = tagOf2(n);
+    const c = kids2(n);
+    switch (t) {
+      case "paragraph": {
+        const s = squash2(inline(c.filter((x) => !["table", "list"].includes(tagOf2(x)))));
+        if (s) out.push(s);
+        out.push(...blocks(c.filter((x) => ["table", "list"].includes(tagOf2(x))), depth));
+        break;
+      }
+      case "list": {
+        const ordered = /^(ordered|numbered|arabic|roman|alpha)/i.test(attr2(n, "listType"));
+        let i = 0;
+        for (const it of c.filter((x) => tagOf2(x) === "item")) {
+          i++;
+          const body = blocks(kids2(it).filter((x) => tagOf2(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"]) : tagOf2(n) === "br" ? " " : plain2(kids2(n));
+  return out;
+};
+function section(n, depth) {
+  const code = child(n, "code");
+  const c = code ? attr2(code, "code") : "";
+  if (SKIP_CODES.has(c)) return [];
+  const title = child(n, "title");
+  let head = title ? squash2(plain2(kids2(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 = kids2(n).filter((x) => !["title", "code", "id", "effectiveTime"].includes(tagOf2(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 = parser3.parse(xml);
+  const d = doc.find((x) => tagOf2(x) === "document");
+  if (!d) return null;
+  const k = kids2(d);
+  const setid = attr2(child(d, "setId") ?? {}, "root").toLowerCase();
+  const version = attr2(child(d, "versionNumber") ?? {}, "value") || null;
+  const effective = isoDate(attr2(child(d, "effectiveTime") ?? {}, "value"));
+  const named = (nodes) => {
+    for (const n of nodes) {
+      if ("#text" in n) continue;
+      if (tagOf2(n) === "manufacturedProduct") {
+        const inner2 = child(n, "manufacturedProduct") ?? n;
+        if (child(inner2, "name")) return inner2;
+      }
+      const h = named(kids2(n));
+      if (h) return h;
+    }
+    return void 0;
+  };
+  const inner = named(k);
+  const brand = inner ? squash2(inline(kids2(child(inner, "name") ?? { name: [] }))) || null : null;
+  const genericNode = inner ? findDeep2(kids2(inner), "genericMedicine") : void 0;
+  const generic = genericNode ? squash2(inline(kids2(child(genericNode, "name") ?? { name: [] }))) || null : null;
+  const formNode = inner ? child(inner, "formCode") : void 0;
+  const form = formNode ? attr2(formNode, "displayName").toLowerCase() || null : null;
+  const org = findDeep2(k, "representedOrganization");
+  const labeler = org ? squash2(inline(kids2(child(org, "name") ?? { name: [] }))) || null : null;
+  const body = findDeep2(k, "structuredBody");
+  const sections2 = body ? blocks(kids2(body), 2) : [];
+  const docTitle = child(d, "title");
+  const lines = [];
+  let cur = "";
+  for (const x of docTitle ? kids2(docTitle) : []) {
+    if (!("#text" in x) && tagOf2(x) === "br") {
+      lines.push(cur);
+      cur = "";
+    } else cur += "#text" in x ? String(x["#text"]) : inline([x]);
+  }
+  lines.push(cur);
+  const highlights = lines.map(squash2).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 {
+    d = JSON.parse(json2);
+  } catch {
+    return null;
+  }
+  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";
+}
+
+// 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 = readFileSync4(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 readFileSync4(p.md, "utf8").includes("_No abstract available._");
+  } catch {
+    return false;
+  }
+}
+function correctionsFromXml(p) {
+  try {
+    return parsePubmedXml(readFileSync4(p.xml, "utf8"))?.corrections ?? [];
+  } catch {
+    return [];
+  }
+}
+function declarationsFromXml(p) {
+  try {
+    const r = parsePubmedXml(readFileSync4(p.xml, "utf8"));
+    return { coi: r?.coi ?? null, funding: r?.funding ?? [] };
+  } catch {
+    return { coi: null, funding: [] };
+  }
+}
+function readMeta(p) {
+  const { fm, all } = parseFrontmatter(readFileSync4(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`;
+  writeFileSync2(tmp, data);
+  renameSync2(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 });
+  mkdirSync3(tmp, { recursive: true });
+  const rename = (n) => n.startsWith(from.entry) ? to.entry + n.slice(from.entry.length) : n;
+  for (const n of readdirSync2(from.entryDir)) if (join6(from.entryDir, n) !== from.meta && !n.endsWith(".tmp")) copyFileSync(join6(from.entryDir, n), join6(tmp, rename(n)));
+  const m = readMeta(from);
+  const copy = { ...m, files: m.files.map(rename) };
+  writeFileSync2(join6(tmp, basename(to.meta)), renderMeta(copy));
+  mkdirSync3(dirname(to.entryDir), { recursive: true });
+  if (existsSync5(to.entryDir)) renameSync2(to.entryDir, old);
+  renameSync2(tmp, to.entryDir);
+  rmSync(old, { recursive: true, force: true });
+  return copy;
+}
+var NOTHING_TO_VERIFY = "no abstract and no full text: nothing to verify";
+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)" };
+  }
+  if (m.level !== "full_text" && !m.has_abstract) return { citable: false, comment: NOTHING_TO_VERIFY };
+  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 = existsSync5(p.fulltextMd) ? readFileSync4(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 existsSync5(p.meta);
+}
+function writeEntry(p, r, xml, converter) {
+  mkdirSync3(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 (!existsSync5(p.fulltextMd) || !existsSync5(p.xml)) return;
+  let r;
+  try {
+    r = parsePubmedXml(readFileSync4(p.xml, "utf8"));
+  } catch {
+    return;
+  }
+  if (!r) return;
+  const md = readFileSync4(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) {
+  mkdirSync3(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) {
+  mkdirSync3(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") {
+  mkdirSync3(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/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 }), onAlert: (message) => onEvent?.({ ok: "alert", 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 existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
+
+// src/verify.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } 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(env = process.env) {
+  const base_url = str("FH_LIBRARY_VERIFY_URL", env).replace(/\/+$/, "");
+  if (!base_url) return null;
+  return {
+    base_url,
+    api_key: str("FH_LIBRARY_VERIFY_API_KEY", env) || null,
+    model: str("FH_LIBRARY_VERIFY_MODEL", env) || DEFAULT_MODEL,
+    threshold: num("FH_LIBRARY_VERIFY_THRESHOLD", 0.5, env, (n) => n > 0 && n < 1),
+    // 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: isHosted(base_url) ? 8e5 : 9e4,
+    timeout_seconds: num("FH_LIBRARY_VERIFY_TIMEOUT_SECS", 60, env, (n) => n > 0)
+  };
+}
+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 = FH_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 = existsSync6(paths.fulltextMd);
+  if (full) return { id: p.requested, basis: "full_text", text: readFileSync5(paths.fulltextMd, "utf8") };
+  const meta = readMeta(paths);
+  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync5(paths.md, "utf8") };
+}
+async function verifyClaim(claim, id, cfg, decide, read = readPaper) {
+  const out = { claim, id, verdict: "error", reason: null, 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 (FH_LIBRARY_VERIFY_URL)" };
+  out.basis = paper.basis;
+  out.glyphs_unresolved = countUnresolved(paper.text);
+  if (paper.basis === "title") return { ...out, verdict: "fail", reason: NOTHING_TO_VERIFY };
+  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 paper.basis === "full_text" ? { ...out, verdict: "fail" } : { ...out, verdict: "unverifiable", reason: "only the abstract is stored and it does not state the claim; the full text may" };
+}
+
+// src/info.ts
+function* metaFiles(dir) {
+  if (!existsSync7(dir)) return;
+  for (const name of readdirSync3(dir)) {
+    const p = join7(dir, name);
+    if (statSync2(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,
+    config: { ...settings(), problems: tiers.problems, sources: sources() },
+    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 existsSync7(libraryDir) ? readdirSync3(libraryDir) : []) {
+    const typeDir = join7(libraryDir, type);
+    if (!statSync2(typeDir).isDirectory()) continue;
+    for (const meta of metaFiles(typeDir)) {
+      const md = readFileSync6(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 = statSync2(join7(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++;
+      } else if (level === "title") info.not_citable++;
+      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 = readFileSync6(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, playwright: PLAYWRIGHT_VERSION, 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], label: m[2], start: i, end: lines.length, bodyEnd: 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].bodyEnd = i + 1 < out.length && out[i + 1].start < out[i].end ? out[i + 1].start : out[i].end;
+    out[i].words = countWords(lines.slice(out[i].start + 1, out[i].end).join("\n"));
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const s of out) {
+    const k = s.heading.toLowerCase();
+    seen.set(k, [...seen.get(k) ?? [], s]);
+  }
+  for (const group of seen.values()) if (group.length > 1) group.forEach((s, i) => {
+    s.label = `${s.heading} [${i + 1}/${group.length}]`;
+  });
+  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, label, words: words2 }) => ({ level, heading: label, words: words2 })) };
+}
+function findSections(md, name) {
+  let q = name.trim().toLowerCase().replace(/^#+\s*/, "");
+  let index = null;
+  const m = /^(.*?)\s*\[(\d+)(?:\/\d+)?\]$/.exec(q);
+  if (m) {
+    q = m[1];
+    index = Number(m[2]);
+  }
+  if (!q) return [];
+  const hits = sections(md).filter((s) => s.level > 1 && s.heading.toLowerCase().includes(q)).sort((a, b) => a.heading.length - b.heading.length);
+  if (!hits.length) return [];
+  const same = hits.filter((s) => s.heading.toLowerCase() === hits[0].heading.toLowerCase()).sort((a, b) => a.start - b.start);
+  if (index !== null) return same[index - 1] ? [same[index - 1]] : [];
+  return same;
+}
+function readSection(md, name, maxChars) {
+  const found = findSections(md, name);
+  if (!found.length) return null;
+  const lines = md.split("\n");
+  if (found.length > 1) {
+    return { ambiguous: found.map((s) => ({ heading: s.label, words: s.words, first_line: (lines.slice(s.start + 1, s.end).find((l) => l.trim()) ?? "").trim().slice(0, 120) })) };
+  }
+  return sectionText(lines, found[0], sections(md), maxChars);
+}
+function sectionText(lines, s, all, maxChars) {
+  const body = lines.slice(s.start + 1, s.bodyEnd).join("\n").trim();
+  const truncated = body.length > maxChars;
+  const text3 = truncated ? body.slice(0, maxChars) + "\n\n[truncated]" : body;
+  const inside = all.filter((c) => c.start > s.start && c.start < s.end);
+  const childLevel = Math.min(...inside.map((c) => c.level));
+  const children = inside.filter((c) => c.level === childLevel).map((c) => ({ heading: c.label, words: c.words }));
+  const out = { heading: s.label, words: s.words, text: text3, returned_words: countWords(truncated ? body.slice(0, maxChars) : body), truncated };
+  if (children.length) out.subsections = children;
+  return out;
+}
+var DECLARATION = /fund|financ|conflict|competing|interest|disclos|support|acknowledg|declar|ethic|contribut|consent|availab|sponsor/i;
+function assembleDeclarations(md, maxChars) {
+  const lines = md.split("\n");
+  const parts = sections(md).filter((s) => s.level > 1 && DECLARATION.test(s.heading));
+  if (!parts.length) return null;
+  const body = parts.map((s) => `### ${s.label}
+
+${lines.slice(s.start + 1, s.bodyEnd).join("\n").trim()}`).join("\n\n");
+  const truncated = body.length > maxChars;
+  return {
+    heading: "Declarations (assembled)",
+    words: countWords(body),
+    text: truncated ? body.slice(0, maxChars) + "\n\n[truncated]" : body,
+    returned_words: countWords(truncated ? body.slice(0, maxChars) : body),
+    truncated,
+    subsections: parts.map((s) => ({ heading: s.label, words: s.words }))
+  };
+}
+var WINDOW_CHARS = 1e3;
+function search(md, query, maxHits, opts = {}) {
+  const window = opts.window ?? WINDOW_CHARS;
+  const terms = [...new Set(tokens(query))];
+  const stems = [...new Set(terms.map(stem))];
+  if (!stems.length) return { passages: [], partial: false, missing_terms: [] };
+  const paras = paragraphs(md, opts.scope);
+  const found = /* @__PURE__ */ new Set();
+  const scored = [];
+  for (const p of paras) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const t of tokens(p.text)) {
+      const s = stem(t);
+      counts.set(s, (counts.get(s) ?? 0) + 1);
+    }
+    const matched = stems.filter((s) => counts.has(s));
+    if (!matched.length) continue;
+    matched.forEach((s) => found.add(s));
+    scored.push({ p, matched, hits: matched.reduce((n, s) => n + counts.get(s), 0) });
+  }
+  const missing_terms = terms.filter((t) => !found.has(stem(t)));
+  const full = scored.filter((x) => x.matched.length === stems.length);
+  const partial = !full.length && scored.length > 0;
+  const df = /* @__PURE__ */ new Map();
+  for (const x of scored) for (const s of x.matched) df.set(s, (df.get(s) ?? 0) + 1);
+  const rarity = (x) => x.matched.reduce((n, s) => n + 1 / df.get(s), 0);
+  const pick = (partial ? scored : full).sort((a, b) => b.matched.length - a.matched.length || (partial ? rarity(b) - rarity(a) : 0) || b.hits - a.hits || a.p.text.length - b.p.text.length).slice(0, maxHits);
+  const passages = pick.map(({ p, matched, hits }) => {
+    const w = clip(p, matched, window);
+    const out = { section: p.section, text: w.text, hits };
+    if (partial) out.matched = terms.filter((t) => matched.includes(stem(t)));
+    if (w.clipped) out.clipped = true;
+    return out;
+  });
+  return { passages, partial, missing_terms };
+}
+function paragraphs(md, scope) {
+  const lines = md.split("\n");
+  const secs = sections(md);
+  const from = scope ? scope.start + 1 : 0, to = scope ? scope.end : lines.length;
+  const sectionAt = (i) => {
+    let h = "";
+    for (const s of secs) {
+      if (s.start <= i) h = s.label;
+      else break;
+    }
+    return h;
+  };
+  const out = [];
+  let para2 = [], paraStart = 0, header = null;
+  const flush = () => {
+    const text3 = para2.join("\n").trim();
+    para2 = [];
+    if (text3) out.push({ section: sectionAt(paraStart), text: text3 });
+  };
+  for (let i = from; i < to; i++) {
+    const l = lines[i];
+    if (!l.trim() || /^#{1,6}\s/.test(l)) {
+      flush();
+      header = null;
+      continue;
+    }
+    if (/^\|/.test(l)) {
+      flush();
+      if (/^\|?\s*:?-{3,}/.test(l)) continue;
+      if (header === null) {
+        header = l.trim();
+        continue;
+      }
+      out.push({ section: sectionAt(i), text: l.trim(), row: header });
+      continue;
+    }
+    header = null;
+    if (!para2.length) paraStart = i;
+    para2.push(l);
+  }
+  flush();
+  return out;
+}
+function clip(p, matched, window) {
+  if (p.row !== void 0) {
+    const text4 = `${p.row}
+${p.text}`;
+    return text4.length <= window ? { text: text4, clipped: false } : { text: text4.slice(0, window) + " \u2026", clipped: true };
+  }
+  if (p.text.length <= window) return { text: p.text, clipped: false };
+  const sents = p.text.split(/(?<=[.!?;])\s+(?=[^a-z])/u);
+  const score = sents.map((s) => {
+    const st = new Set(tokens(s).map(stem));
+    return matched.filter((m) => st.has(m)).length;
+  });
+  let best = 0;
+  score.forEach((v, i) => {
+    if (v > score[best]) best = i;
+  });
+  let lo = best, hi = best, len = sents[best].length;
+  for (; ; ) {
+    const left = lo > 0 ? sents[lo - 1].length + 1 : Infinity;
+    const right = hi + 1 < sents.length ? sents[hi + 1].length + 1 : Infinity;
+    if (Math.min(left, right) === Infinity || len + Math.min(left, right) > window) break;
+    if (right <= left) {
+      hi++;
+      len += right;
+    } else {
+      lo--;
+      len += left;
+    }
+  }
+  let text3 = sents.slice(lo, hi + 1).join(" ");
+  if (text3.length > window) text3 = text3.slice(0, window) + " \u2026";
+  if (lo > 0) text3 = "\u2026 " + text3;
+  if (hi + 1 < sents.length && !text3.endsWith("\u2026")) text3 += " \u2026";
+  return { text: text3, clipped: true };
+}
+var fold = (s) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[*_~^]/g, "").replace(/[-/]/g, " ");
+function tokens(s) {
+  return (fold(s).match(/[\p{L}\p{N}][\p{L}\p{N}'.%]*/gu) ?? []).map((t) => t.replace(/[.']+$/, "")).filter(Boolean);
+}
+function stem(w) {
+  if (/\d/.test(w)) return w;
+  if (w.length > 3 && w.endsWith("s") && !w.endsWith("ss")) w = w.slice(0, -1);
+  if (w.endsWith("ie")) return w.slice(0, -2) + "y";
+  if (w.length >= 4) w = w.replace(/(ation|ing|ed|e)$/, "");
+  return w;
+}
+
+// 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", "fh-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(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
+  } catch {
+    return { name: "fh-library", version: "0.0.0" };
+  }
+})();
+var INSTRUCTIONS = `fh-library keeps a local library of scientific papers, FDA drug labels and clinical trial records, so you can check what a source actually says. The server downloads each record, converts it to Markdown and stores it on disk. Every tool returns a small JSON answer; the document itself never enters your context. One ID per call.
+
+IDs \u2014 always "type:value"
+- pmid:30955454 \u2014 a paper by PubMed ID. Bare digits are taken as a PMID.
+- doi:10.\u2026 \u2014 a paper by DOI. A DOI PubMed indexes is stored under its PMID; any other gets its record from Crossref.
+- dailymed:<set ID> \u2014 an FDA prescribing-information label, current version. The set ID is the "setid=" value in the label's DailyMed URL.
+- nct:05173896 \u2014 a ClinicalTrials.gov trial record, current version. NCT05173896 is accepted too.
+
+Tools
+- version() \u2014 package name, version, library directory.
+- info(ids?) \u2014 the whole library: entry counts by type and level, the retrieval sources, browsers, the decision model, the configuration. ids=true lists every entry.
+- add(id) \u2014 download and store one record; returns its status. A stored full text is returned without any download; an abstract-level record retries only the sources that failed transiently; a record older than 30 days gets its correction notices re-read.
+- status(id) \u2014 the status of one record without downloading; level "missing" when it is not stored.
+- read(id, section?, query?, max_chars?, max_hits?) \u2014 one small piece of a stored document: its outline, one section, or the passages matching a query.
+- verify(claim, id) \u2014 does this one source state this one finding? A decision model judges the stored text and returns a verdict.
+
+Hints
+- read and verify store a missing record themselves; the read answer then carries added: true. No add necessary first.
+- citable false \u2014 the paper is retracted (a retraction notice, or PubMed's publication type), or holds nothing to read: no abstract and no full text. comment says which; corrections lists the notices as {type, pmid, source}.
+- level \u2014 what is stored: "full_text", "abstract" (no full text could be found; attempts names each source tried and why it failed) or "title" (not even an abstract; citable false).
+- error "pmid not found" or "invalid id" \u2014 the ID itself is wrong; the same call gives the same answer.
+- Calls may run in parallel: add, read and verify. Two calls on the same missing record share one add.
+
+Verifying a claim
+- verify judges one claim against one stored document. A finding backed by three papers takes three calls with the same claim.
+- It expects the finding as a complete sentence: who or what, the intervention, the outcome, the number. Citation markers and commentary around the finding are not part of what a document states.
+- It can only confirm what this one document states. A finding about two interventions from two papers is two claims, each against its own paper. A summary of several trials ("trials used 60\u2013200 mg") is stated by none of them; the dose this one trial used is.
+- It returns error for a claim under four words, a sentence fragment, or a claim still containing citations. A short finding with its setting (in vitro, cell line, dose) is accepted; filler words do not help.
+- verdict "pass" \u2014 the document states the claim. score is the model's probability.
+- verdict "fail" \u2014 the stored full text does not state the claim as worded; read with a query shows what the document does say. Or, with basis "title", nothing is stored to read: reason says so, score is null.
+- verdict "unverifiable" \u2014 only the abstract is stored and it does not state the claim; the full text may (reason says so). A retry gives the same answer until a full text is stored.
+- glyphs_unresolved above 0 \u2014 the PDF font lost symbols (minus, \xB1, \u2264); a fail on a number may be the font. read shows the passage.
+- superseded true \u2014 a published correction replaced the figure the claim uses; the status's corrections holds the notice.
+
+Reading a document
+- read with only the ID returns the outline: every heading with its word count, and whether the full text or only the abstract is stored.
+- section \u2014 a heading from the outline, matched case-insensitively as a substring; the text is capped at max_chars (default 6000). A heading that occurs several times is listed as "Participants [3/12]" and is addressed that way.
+- query \u2014 returns the passages holding every term: up to max_hits (default 5), each at most 1000 characters around the matches, with its section, best first. It works best with two or three distinctive terms the document itself would use (a measure and a unit, an outcome and a group, a compound name), not a claim sentence. Case, accents, hyphens, plurals and -ed/-ing forms are matched.
+- partial true \u2014 no passage holds every term; missing_terms are the words the document never uses. The same query without them finds the passage if there is one.
+- Numbers are often in tables; a matching table row comes with its header row.
+- section and query together search inside that section only.
+- section "Abstract" on a full text without one returns the stored abstract. section "Declarations" returns funding, conflicts of interest, acknowledgements and ethics statements, assembled when the document has no section of that name.
+
+Status fields: requested, type, id, entry, entry_dir, library_dir, pmid, pmcid, doi, setid, nctid, publications, title, first_author, year, publication_types, retracted, corrections, coi (conflict-of-interest statement), funding, citable, comment, has_abstract, level, version, retrieved_by, retrieved_date, pubmed_checked, attempts, files, glyphs_unresolved, error.
+
+Where records come from: PubMed for the record and abstract; the full text from a file you drop into <library>/inbox/ (PMID in the file name), PubMed Central, Europe PMC, publishers' text-mining links, Unpaywall, OpenAlex, CORE, and a proxy URL template from the configuration. Every action is appended as one line to <library>/library.log.`;
+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(" ") : "";
+}
+var modelFailure = (error, cfg) => error.startsWith("no verify model configured") || !!cfg && error.startsWith(`${cfg.model}:`);
+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 === "alert") {
+        log("add", requested, `!! ${e.message}`);
+        return;
+      }
+      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(
+        "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("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("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("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("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("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("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("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("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("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("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("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("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("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("add", requested, `ctgov failed: ${msg}`);
+      return { ...status, error: msg };
+    }
+  }
+  server2.tool(
+    "add",
+    "Download and store one record \u2014 a paper (pmid:, doi:), a drug label (dailymed:<set ID>) or a trial record (nct:<8 digits>) \u2014 and return its status JSON. A paper gets its record, abstract and correction notices from PubMed (Crossref for a DOI PubMed does not index), then the full text from the configured sources; a label or trial record is stored as a full text. A stored full text is returned without any download; an abstract-level record retries only sources that failed transiently; a record older than 30 days gets its notices re-read.",
+    { id: idSchema },
+    ({ id }) => addEntry(id)
+  );
+  const inflight = /* @__PURE__ */ new Map();
+  function addEntry(id) {
+    const key = parseId(id).requested;
+    let p = inflight.get(key);
+    if (!p) {
+      p = addEntryNow(id).finally(() => inflight.delete(key));
+      inflight.set(key, p);
+    }
+    return p;
+  }
+  async function addEntryNow(id) {
+    const t0 = Date.now();
+    let parsed = parseId(id);
+    if (parsed.error) {
+      log("add", parsed.requested, `error ${parsed.error}`);
+      return json({ ...emptyStatus(parsed.requested, parsed.type, parsed.id, FH_LIBRARY_DIR), error: parsed.error });
+    }
+    let copyTo = null;
+    if (parsed.type === "doi") {
+      const doiPaths = entryPaths(FH_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("add", parsed.requested, `pubmed lookup failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (pmid && !entryExists(entryPaths(FH_LIBRARY_DIR, "pmid", pmid))) {
+          try {
+            if (!parsePubmedXml(await fetchPubmedXml(pmid))) {
+              log("add", parsed.requested, `pmid:${pmid} has no readable PubMed record \u2014 kept as doi:`);
+              pmid = null;
+            }
+          } catch {
+          }
+        }
+        if (pmid) log("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, FH_LIBRARY_DIR);
+    const isDoi = parsed.type === "doi";
+    const paths = entryPaths(FH_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, FH_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("add", parsed.requested, `refreshed crossref${noticeTag(meta) !== before ? ` changed: ${before.trim() || "none"} \u2192 ${noticeTag(meta).trim() || "none"}` : ""}`);
+          } else log("add", parsed.requested, "refresh failed: doi not found");
+        } catch (e) {
+          log("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("add", parsed.requested, `refreshed pubmed_checked=${meta.pubmed_checked}${noticeTag(meta) !== before ? ` changed: ${before.trim() || "none"} \u2192 ${noticeTag(meta).trim() || "none"}` : ""}`);
+          } else log("add", parsed.requested, "refresh failed: pmid not found");
+        } catch (e) {
+          log("add", parsed.requested, `refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+      if (meta.level === "full_text") {
+        log("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("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("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("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("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("add", parsed.requested, `pubmed failed: ${msg}`);
+        return json({ ...status, error: msg });
+      }
+      const record = parsePubmedXml(xml);
+      if (!record) {
+        log("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("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("add", parsed.requested, `done ${secs} level=${levelWord(meta)} retrieved_by=${meta.retrieved_by}`);
+    return finish(meta);
+  }
+  server2.tool(
+    "status",
+    'Read-only status of the library entry for one paper ID: the same status JSON as 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, FH_LIBRARY_DIR);
+      if (parsed.error) {
+        log("status", parsed.requested, `error ${parsed.error}`);
+        return json({ ...status, error: parsed.error });
+      }
+      const paths = entryPaths(FH_LIBRARY_DIR, parsed.type, parsed.id);
+      if (entryExists(paths)) {
+        const s = readStatus(paths, status);
+        log("status", parsed.requested, `level=${s.level}`);
+        return json(s);
+      }
+      log("status", parsed.requested, "level=missing");
+      return json({ ...status, entry: paths.entry, entry_dir: paths.entryDir, level: "missing" });
+    }
+  );
+  server2.tool(
+    "read",
+    `One piece of a stored document's Markdown, never the whole. No section/query: the outline (headings with word counts; full text or abstract only). section: that heading's own text (case-insensitive substring; a repeated heading as "Participants [3/12]"), capped at max_chars, its subsections listed. query: passages holding every term, each a window of at most 1000 chars with its section, best first, at most max_hits; partial: true with missing_terms when no passage holds them all. section and query together: inside that section. A missing paper is added first (added: true).`,
+    {
+      id: idSchema,
+      section: z.string().optional().describe("Heading from the outline (case-insensitive substring)."),
+      query: z.string().optional().describe("Two or three distinctive terms the paper itself would use \u2014 a measure and a unit, an outcome and a group, a compound name \u2014 not the claim. Passages holding all of them are returned, else the best partial matches. With section: inside that section."),
+      max_chars: z.number().int().positive().optional().describe("Cap for section text (default 6000); passages are capped at 1000 chars each regardless."),
+      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("read", parsed.requested, `error ${parsed.error}`);
+        return out({ requested: parsed.requested, error: parsed.error });
+      }
+      const paths = entryPaths(FH_LIBRARY_DIR, parsed.type, parsed.id);
+      let added = false;
+      if (!entryExists(paths)) {
+        log("read", parsed.requested, "missing adding first");
+        const r = JSON.parse((await addEntry(id)).content[0].text);
+        if (!entryExists(paths)) {
+          log("read", parsed.requested, `error ${r.error ?? "add failed"}`);
+          return out({ requested: parsed.requested, entry: paths.entry, error: `not in the library and add failed: ${r.error ?? "unknown"}` });
+        }
+        added = true;
+      }
+      const full = existsSync8(paths.fulltextMd);
+      const md = readFileSync7(full ? paths.fulltextMd : paths.md, "utf8");
+      const text3 = full ? "full_text" : "abstract";
+      const base = added ? { requested: parsed.requested, entry: paths.entry, text: text3, added: true } : { requested: parsed.requested, entry: paths.entry, text: text3 };
+      const headings2 = () => outline(md, text3).sections;
+      const describe2 = (r) => `${r.passages.length} passages${r.partial ? " partial" : ""}${r.passages.filter((x) => x.clipped).length ? ` ${r.passages.filter((x) => x.clipped).length} clipped` : ""}${r.missing_terms.length ? ` (missing: ${r.missing_terms.join(", ")})` : ""}`;
+      if (section2 && query) {
+        const found = findSections(md, section2);
+        if (found.length !== 1) {
+          log("read", parsed.requested, `section "${section2}" query "${query}" \u2192 ${found.length ? `${found.length} sections match` : "section not found"}`);
+          if (!found.length) return out({ ...base, error: `no section matching "${section2}"`, outline: headings2() });
+          return out({ ...base, error: `${found.length} sections match "${section2}" \u2014 name one, e.g. "${found[0].label}"`, ambiguous: found.map((s) => ({ heading: s.label, words: s.words })) });
+        }
+        const r = search(md, query, max_hits ?? 5, { scope: found[0] });
+        log("read", parsed.requested, `section "${found[0].label}" query "${query}" \u2192 ${describe2(r)}`);
+        return out({ ...base, section: found[0].label, query, ...r });
+      }
+      if (section2) {
+        const cap = max_chars ?? 6e3;
+        let sec = readSection(md, section2, cap);
+        let via = "";
+        if (!sec && /abstract/i.test(section2) && full && existsSync8(paths.md)) {
+          sec = readSection(readFileSync7(paths.md, "utf8"), "abstract", cap);
+          via = " (from the abstract file)";
+        }
+        if (!sec && /declaration/i.test(section2)) {
+          sec = assembleDeclarations(md, cap);
+          via = " (assembled)";
+        }
+        if (!sec) {
+          log("read", parsed.requested, `section "${section2}" not found`);
+          return out({ ...base, error: `no section matching "${section2}"`, outline: headings2() });
+        }
+        if ("ambiguous" in sec) {
+          log("read", parsed.requested, `section "${section2}" \u2192 ${sec.ambiguous.length} sections match`);
+          return out({ ...base, error: `${sec.ambiguous.length} sections match "${section2}" \u2014 name one, e.g. "${sec.ambiguous[0].heading}"`, ...sec });
+        }
+        log("read", parsed.requested, `section "${section2}" \u2192 "${sec.heading}" ${sec.words} words${sec.truncated ? ` truncated to ${sec.returned_words}` : ""}${sec.subsections ? ` ${sec.subsections.length} subsections` : ""}${via}`);
+        return out({ ...base, ...sec });
+      }
+      if (query) {
+        const r = search(md, query, max_hits ?? 5);
+        log("read", parsed.requested, `query "${query}" \u2192 ${describe2(r)}`);
+        if (!r.passages.length) return out({ ...base, query, ...r, sections: headings2().map((s) => s.heading) });
+        return out({ ...base, query, ...r });
+      }
+      const o = outline(md, text3);
+      log("read", parsed.requested, `outline ${o.sections.length} sections ${o.words} words`);
+      return out({ ...base, ...o });
+    }
+  );
+  server2.tool(
+    "verify",
+    "Does one source state one finding of a review? claim: the finding as a complete statement (subject, intervention, outcome, number), without citations or the review's framing, and only what this source reports. id: one source the review cites for it \u2014 paper, drug label (dailymed:\u2026) or trial record (nct:\u2026); added first when missing. The server reads the stored text and asks a decision model; nothing enters your context. verdict: pass (score is the probability) | fail (the full text does not state it; or only the title is stored \u2014 reason says so) | unverifiable (only the abstract is stored and does not state it \u2014 reason says so) | error (claim refused: under four words, a fragment, carrying citations; add failed; no model; model failure). basis: full_text | abstract | title. glyphs_unresolved: symbols the PDF font lost; above 0 a failed number may be the font. superseded: true when a stored correction replaced the claim's figure.",
+    {
+      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 pid = parseId(id);
+      if (!pid.error && !entryExists(entryPaths(FH_LIBRARY_DIR, pid.type, pid.id))) {
+        log("verify", pid.requested, "missing adding first");
+        await addEntry(id);
+      }
+      const r = await verifyClaim(claim, id, cfg, cfg ? decider(cfg) : null);
+      const secs = `${((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0")}s`;
+      log("verify", r.id, r.error ? `${modelFailure(r.error, cfg) ? "!! " : ""}${secs} verdict=${"error".padEnd(12)} ${r.error} | ${claim}` : `${secs} verdict=${r.verdict.padEnd(12)} 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(
+    "info",
+    "The whole library as JSON: library directory and host; entry count and size on disk; per type (pmid, doi, dailymed, nct) the entries by level (full_text, abstract, title) and retractions; counts of retracted and not-citable entries and of errata, expressions of concern and updates; the retrieval sources in run order and which are off (tiers); the download ladder with the browsers and the Playwright version they must run (download); the configuration and where each value came from \u2014 environment, .env or default, never the value (config); the decision model behind verify and whether it answers right now (verify). ids=true also lists every entry ID.",
+    { ids: z.boolean().optional().describe("Also list every entry ID (type:value).") },
+    async ({ ids }) => {
+      const info = libraryInfo(FH_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("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(
+    "version",
+    "Get the running fh-library MCP server's package name and version, and the resolved library directory. Useful to confirm which build is loaded.",
+    {},
+    async () => {
+      log("version", null, `${pkg.name} ${pkg.version}`);
+      return { content: [{ type: "text", text: `${pkg.name} v${pkg.version} \xB7 host: ${HOST} \xB7 library_dir: ${FH_LIBRARY_DIR} \xB7 log: ${LOG_FILE}` }] };
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer(
+  { name: pkg.name, version: pkg.version },
+  { instructions: INSTRUCTIONS }
+);
+registerTools(server);
+for (const problem of resolveTiers().problems) log("startup", null, `!! ${problem}`);
+var transport = new StdioServerTransport();
+await server.connect(transport);