@ncukondo/reference-manager 0.5.1 → 0.5.3

package/dist/chunks/index-Bl_mOQRe.js

@@ -0,0 +1,1657 @@
+import { Hono } from "hono";
+import { e as CslItemSchema, d as detectDuplicate, t as tokenize, s as search$1, b as sortResults, L as Library, F as FileWatcher } from "./file-watcher-CBAbblss.js";
+import { existsSync, readFileSync } from "node:fs";
+import { Cite } from "@citation-js/core";
+import "@citation-js/plugin-doi";
+import "@citation-js/plugin-isbn";
+import "@citation-js/plugin-bibtex";
+import "@citation-js/plugin-ris";
+import { z } from "zod";
+import "node:path";
+import "@citation-js/plugin-csl";
+async function updateReference(library, options) {
+  const { identifier, idType = "id", updates, onIdCollision = "fail" } = options;
+  const updateResult = await library.update(identifier, updates, { idType, onIdCollision });
+  if (!updateResult.updated) {
+    const result2 = { updated: false };
+    if (updateResult.idCollision) {
+      result2.idCollision = true;
+    }
+    return result2;
+  }
+  await library.save();
+  const result = { updated: true };
+  if (updateResult.item) {
+    result.item = updateResult.item;
+  }
+  if (updateResult.idChanged && updateResult.newId) {
+    result.idChanged = true;
+    result.newId = updateResult.newId;
+  }
+  return result;
+}
+const BUILTIN_STYLES = ["apa", "vancouver", "harvard"];
+function isBuiltinStyle(styleName) {
+  return BUILTIN_STYLES.includes(styleName);
+}
+const DEFAULT_TTL_MS = 60 * 60 * 1e3;
+const pmidCache = /* @__PURE__ */ new Map();
+const doiCache = /* @__PURE__ */ new Map();
+const isbnCache = /* @__PURE__ */ new Map();
+function isEntryValid(entry) {
+  const now = Date.now();
+  return now - entry.cachedAt < entry.ttlMs;
+}
+function getFromCache(cache, key) {
+  const entry = cache.get(key);
+  if (!entry) {
+    return void 0;
+  }
+  if (!isEntryValid(entry)) {
+    cache.delete(key);
+    return void 0;
+  }
+  return entry.item;
+}
+function storeInCache(cache, key, item, config) {
+  const ttlMs = DEFAULT_TTL_MS;
+  cache.set(key, {
+    item,
+    cachedAt: Date.now(),
+    ttlMs
+  });
+}
+function getPmidFromCache(pmid) {
+  return getFromCache(pmidCache, pmid);
+}
+function cachePmidResult(pmid, item, config) {
+  storeInCache(pmidCache, pmid, item);
+}
+function getDoiFromCache(doi) {
+  return getFromCache(doiCache, doi);
+}
+function cacheDoiResult(doi, item, config) {
+  storeInCache(doiCache, doi, item);
+}
+function getIsbnFromCache(isbn) {
+  return getFromCache(isbnCache, isbn);
+}
+function cacheIsbnResult(isbn, item, config) {
+  storeInCache(isbnCache, isbn, item);
+}
+const DOI_URL_PREFIXES$1 = [
+  "https://doi.org/",
+  "http://doi.org/",
+  "https://dx.doi.org/",
+  "http://dx.doi.org/"
+];
+function normalizeDoi(doi) {
+  const trimmed = doi.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lowerInput = trimmed.toLowerCase();
+  for (const prefix of DOI_URL_PREFIXES$1) {
+    if (lowerInput.startsWith(prefix.toLowerCase())) {
+      return trimmed.slice(prefix.length);
+    }
+  }
+  return trimmed;
+}
+function normalizePmid(pmid) {
+  const trimmed = pmid.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const normalized = trimmed.replace(/^pmid:\s*/i, "");
+  return normalized.trim();
+}
+function normalizeIsbn(isbn) {
+  const trimmed = isbn.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (!/^isbn:/i.test(trimmed)) {
+    return "";
+  }
+  let normalized = trimmed.replace(/^isbn:\s*/i, "");
+  normalized = normalized.replace(/[-\s]/g, "");
+  normalized = normalized.toUpperCase();
+  return normalized;
+}
+const EXTENSION_MAP = {
+  ".json": "json",
+  ".bib": "bibtex",
+  ".ris": "ris"
+};
+const DOI_URL_PREFIXES = [
+  "https://doi.org/",
+  "http://doi.org/",
+  "https://dx.doi.org/",
+  "http://dx.doi.org/"
+];
+function detectByExtension(input) {
+  if (!input) return "unknown";
+  const dotIndex = input.lastIndexOf(".");
+  if (dotIndex === -1 || dotIndex === input.length - 1) {
+    return "unknown";
+  }
+  const ext = input.slice(dotIndex).toLowerCase();
+  return EXTENSION_MAP[ext] ?? "unknown";
+}
+function detectByContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return "unknown";
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    return "json";
+  }
+  if (trimmed.startsWith("@")) {
+    return "bibtex";
+  }
+  if (trimmed.startsWith("TY  -")) {
+    return "ris";
+  }
+  return detectIdentifier(trimmed);
+}
+function detectIdentifier(input) {
+  const parts = input.split(/\s+/).filter((p) => p.length > 0);
+  if (parts.length === 0) {
+    return "unknown";
+  }
+  const formats = [];
+  for (const part of parts) {
+    const format = detectSingleIdentifier(part);
+    if (format === "unknown") {
+      return "unknown";
+    }
+    formats.push(format);
+  }
+  if (formats.length === 1) {
+    return formats[0];
+  }
+  return "identifiers";
+}
+function detectSingleIdentifier(input) {
+  if (isDoi(input)) {
+    return "doi";
+  }
+  if (isIsbn(input)) {
+    return "isbn";
+  }
+  if (isPmid(input)) {
+    return "pmid";
+  }
+  return "unknown";
+}
+function isDoi(input) {
+  for (const prefix of DOI_URL_PREFIXES) {
+    if (input.toLowerCase().startsWith(prefix.toLowerCase())) {
+      const remainder = input.slice(prefix.length);
+      return isDoiFormat(remainder);
+    }
+  }
+  return isDoiFormat(input);
+}
+function isDoiFormat(input) {
+  if (!input.startsWith("10.")) {
+    return false;
+  }
+  if (input.length <= 3) {
+    return false;
+  }
+  const slashIndex = input.indexOf("/");
+  if (slashIndex === -1 || slashIndex <= 3) {
+    return false;
+  }
+  return true;
+}
+function isPmid(input) {
+  if (!input || input.length === 0) {
+    return false;
+  }
+  const normalized = normalizePmid(input);
+  if (!normalized) {
+    return false;
+  }
+  return /^\d+$/.test(normalized);
+}
+function isIsbn(input) {
+  if (!input || input.length === 0) {
+    return false;
+  }
+  const normalized = normalizeIsbn(input);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized.length !== 10 && normalized.length !== 13) {
+    return false;
+  }
+  if (normalized.length === 10) {
+    if (!/^\d{9}[\dX]$/.test(normalized)) {
+      return false;
+    }
+    return true;
+  }
+  if (!/^\d{13}$/.test(normalized)) {
+    return false;
+  }
+  return true;
+}
+const RATE_LIMITS = {
+  pubmed: {
+    withoutApiKey: 3,
+    // 3 req/sec
+    withApiKey: 10
+    // 10 req/sec
+  },
+  crossref: 50,
+  // 50 req/sec
+  isbn: 10
+  // 10 req/sec (conservative for Google Books API daily limit)
+};
+class RateLimiterImpl {
+  requestsPerSecond;
+  intervalMs;
+  _lastRequestTime = 0;
+  _pending = Promise.resolve();
+  constructor(requestsPerSecond) {
+    this.requestsPerSecond = requestsPerSecond;
+    this.intervalMs = 1e3 / requestsPerSecond;
+  }
+  get lastRequestTime() {
+    return this._lastRequestTime;
+  }
+  async acquire() {
+    this._pending = this._pending.then(() => this._acquireInternal());
+    return this._pending;
+  }
+  async _acquireInternal() {
+    const now = Date.now();
+    const elapsed = now - this._lastRequestTime;
+    const waitTime = Math.max(0, this.intervalMs - elapsed);
+    if (waitTime > 0 && this._lastRequestTime > 0) {
+      await this._delay(waitTime);
+    }
+    this._lastRequestTime = Date.now();
+  }
+  _delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+const limiters = /* @__PURE__ */ new Map();
+function createRateLimiter(options) {
+  return new RateLimiterImpl(options.requestsPerSecond);
+}
+function getRateLimiter(api, config) {
+  const existing = limiters.get(api);
+  if (existing) {
+    return existing;
+  }
+  const requestsPerSecond = getRequestsPerSecond(api, config);
+  const limiter = createRateLimiter({ requestsPerSecond });
+  limiters.set(api, limiter);
+  return limiter;
+}
+function getRequestsPerSecond(api, config) {
+  switch (api) {
+    case "pubmed":
+      return config.pubmedApiKey ? RATE_LIMITS.pubmed.withApiKey : RATE_LIMITS.pubmed.withoutApiKey;
+    case "crossref":
+      return RATE_LIMITS.crossref;
+    case "isbn":
+      return RATE_LIMITS.isbn;
+  }
+}
+const PMC_API_BASE = "https://pmc.ncbi.nlm.nih.gov/api/ctxp/v1/pubmed/";
+const DEFAULT_TIMEOUT_MS = 1e4;
+const DOI_PATTERN = /^10\.\d{4,}(?:\.\d+)*\/\S+$/;
+function buildPmcUrl(pmids, config) {
+  const url = new URL(PMC_API_BASE);
+  url.searchParams.set("format", "csl");
+  for (const pmid of pmids) {
+    url.searchParams.append("id", pmid);
+  }
+  if (config.email) {
+    url.searchParams.set("email", config.email);
+  }
+  if (config.apiKey) {
+    url.searchParams.set("api_key", config.apiKey);
+  }
+  return url.toString();
+}
+function extractPmidFromId(id) {
+  if (!id) return void 0;
+  const match = id.match(/^pmid:(\d+)$/);
+  return match?.[1];
+}
+function parseRawItems(rawItems) {
+  const foundItems = /* @__PURE__ */ new Map();
+  const validationErrors = /* @__PURE__ */ new Map();
+  for (const rawItem of rawItems) {
+    const parseResult = CslItemSchema.safeParse(rawItem);
+    if (parseResult.success) {
+      const pmid = extractPmidFromId(parseResult.data.id);
+      if (pmid) {
+        foundItems.set(pmid, parseResult.data);
+      }
+    } else {
+      const maybeId = rawItem?.id;
+      const pmid = extractPmidFromId(maybeId);
+      if (pmid) {
+        validationErrors.set(pmid, parseResult.error.message);
+      }
+    }
+  }
+  return { foundItems, validationErrors };
+}
+function buildPmidResult(pmid, foundItems, validationErrors) {
+  const item = foundItems.get(pmid);
+  if (item) {
+    return { pmid, success: true, item };
+  }
+  const validationError = validationErrors.get(pmid);
+  if (validationError) {
+    return {
+      pmid,
+      success: false,
+      error: `Invalid CSL-JSON data: ${validationError}`
+    };
+  }
+  return {
+    pmid,
+    success: false,
+    error: `PMID ${pmid} not found`
+  };
+}
+async function fetchPmids(pmids, config) {
+  if (pmids.length === 0) {
+    return [];
+  }
+  const rateLimiterConfig = config.apiKey ? { pubmedApiKey: config.apiKey } : {};
+  const rateLimiter = getRateLimiter("pubmed", rateLimiterConfig);
+  await rateLimiter.acquire();
+  const url = buildPmcUrl(pmids, config);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const errorMsg = `HTTP ${response.status}: ${response.statusText}`;
+      return pmids.map((pmid) => ({
+        pmid,
+        success: false,
+        error: errorMsg
+      }));
+    }
+    const data = await response.json();
+    const rawItems = Array.isArray(data) ? data : [data];
+    const { foundItems, validationErrors } = parseRawItems(rawItems);
+    return pmids.map((pmid) => buildPmidResult(pmid, foundItems, validationErrors));
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return pmids.map((pmid) => ({
+      pmid,
+      success: false,
+      error: errorMsg
+    }));
+  }
+}
+async function fetchDoi(doi) {
+  if (!DOI_PATTERN.test(doi)) {
+    return {
+      success: false,
+      error: `Invalid DOI format: ${doi}`
+    };
+  }
+  const rateLimiter = getRateLimiter("crossref", {});
+  await rateLimiter.acquire();
+  try {
+    const cite2 = await Cite.async(doi);
+    const rawItems = cite2.get({ format: "real", type: "json" });
+    if (!rawItems || !Array.isArray(rawItems) || rawItems.length === 0) {
+      return {
+        success: false,
+        error: `No data returned for DOI ${doi}`
+      };
+    }
+    const parseResult = CslItemSchema.safeParse(rawItems[0]);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        error: `Invalid CSL-JSON data for DOI ${doi}: ${parseResult.error.message}`
+      };
+    }
+    return { success: true, item: parseResult.data };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+const ISBN10_PATTERN = /^\d{9}[\dX]$/;
+const ISBN13_PATTERN = /^\d{13}$/;
+async function fetchIsbn(isbn) {
+  if (!ISBN10_PATTERN.test(isbn) && !ISBN13_PATTERN.test(isbn)) {
+    return {
+      success: false,
+      error: `Invalid ISBN format: ${isbn}`
+    };
+  }
+  const rateLimiter = getRateLimiter("isbn", {});
+  await rateLimiter.acquire();
+  try {
+    const cite2 = await Cite.async(isbn);
+    const rawItems = cite2.get({ format: "real", type: "json" });
+    if (!rawItems || !Array.isArray(rawItems) || rawItems.length === 0) {
+      return {
+        success: false,
+        error: `No data returned for ISBN ${isbn}`
+      };
+    }
+    const parseResult = CslItemSchema.safeParse(rawItems[0]);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        error: `Invalid CSL-JSON data for ISBN ${isbn}: ${parseResult.error.message}`
+      };
+    }
+    return { success: true, item: parseResult.data };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+function parseBibtex(content) {
+  return parseWithCitationJs(content, "bibtex");
+}
+function parseRis(content) {
+  return parseWithCitationJs(content, "ris");
+}
+function parseWithCitationJs(content, format) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return { success: true, items: [] };
+  }
+  try {
+    const cite2 = new Cite(trimmed);
+    const items = cite2.get({ format: "real", type: "json" });
+    if (!items || items.length === 0) {
+      if (isEmptyFormat(trimmed, format)) {
+        return { success: true, items: [] };
+      }
+      return {
+        success: false,
+        items: [],
+        error: `No valid ${format.toUpperCase()} entries found`
+      };
+    }
+    return { success: true, items };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (isEmptyFormat(trimmed, format)) {
+      return { success: true, items: [] };
+    }
+    return {
+      success: false,
+      items: [],
+      error: `Failed to parse ${format.toUpperCase()}: ${errorMessage}`
+    };
+  }
+}
+function isEmptyFormat(content, format) {
+  if (format === "bibtex") {
+    const lines = content.split("\n");
+    return lines.every((line) => {
+      const trimmed = line.trim();
+      return trimmed === "" || trimmed.startsWith("%");
+    });
+  }
+  return false;
+}
+function classifyIdentifiers(identifiers) {
+  const pmids = [];
+  const dois = [];
+  const isbns = [];
+  const unknowns = [];
+  for (const id of identifiers) {
+    if (isPmid(id)) {
+      pmids.push(normalizePmid(id));
+    } else if (isDoi(id)) {
+      dois.push(normalizeDoi(id));
+    } else if (isIsbn(id)) {
+      isbns.push(normalizeIsbn(id));
+    } else {
+      unknowns.push(id);
+    }
+  }
+  return { pmids, dois, isbns, unknowns };
+}
+function buildUnknownResults(unknowns) {
+  return unknowns.map((unknown) => ({
+    success: false,
+    error: `Cannot interpret '${unknown}' as identifier (not a valid PMID or DOI)`,
+    source: unknown
+  }));
+}
+async function fetchPmidsWithCache(pmids, pubmedConfig) {
+  const results = [];
+  const pmidsToFetch = [];
+  for (const pmid of pmids) {
+    const cached = getPmidFromCache(pmid);
+    if (cached) {
+      results.push({ success: true, item: cached, source: pmid });
+    } else {
+      pmidsToFetch.push(pmid);
+    }
+  }
+  if (pmidsToFetch.length > 0) {
+    const fetchResults = await fetchPmids(pmidsToFetch, pubmedConfig);
+    for (const fetchResult of fetchResults) {
+      if (fetchResult.success) {
+        cachePmidResult(fetchResult.pmid, fetchResult.item);
+        results.push({
+          success: true,
+          item: fetchResult.item,
+          source: fetchResult.pmid
+        });
+      } else {
+        results.push({
+          success: false,
+          error: fetchResult.error,
+          source: fetchResult.pmid
+        });
+      }
+    }
+  }
+  return results;
+}
+async function fetchDoisWithCache(dois) {
+  const results = [];
+  for (const doi of dois) {
+    const cached = getDoiFromCache(doi);
+    if (cached) {
+      results.push({ success: true, item: cached, source: doi });
+      continue;
+    }
+    const fetchResult = await fetchDoi(doi);
+    if (fetchResult.success) {
+      cacheDoiResult(doi, fetchResult.item);
+      results.push({ success: true, item: fetchResult.item, source: doi });
+    } else {
+      results.push({ success: false, error: fetchResult.error, source: doi });
+    }
+  }
+  return results;
+}
+async function fetchIsbnsWithCache(isbns) {
+  const results = [];
+  for (const isbn of isbns) {
+    const cached = getIsbnFromCache(isbn);
+    if (cached) {
+      results.push({ success: true, item: cached, source: isbn });
+      continue;
+    }
+    const fetchResult = await fetchIsbn(isbn);
+    if (fetchResult.success) {
+      cacheIsbnResult(isbn, fetchResult.item);
+      results.push({ success: true, item: fetchResult.item, source: isbn });
+    } else {
+      results.push({ success: false, error: fetchResult.error, source: isbn });
+    }
+  }
+  return results;
+}
+function parseJsonContent(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    if (items.length === 0) {
+      return { results: [] };
+    }
+    const results = [];
+    for (const item of items) {
+      const parseResult = CslItemSchema.safeParse(item);
+      if (parseResult.success) {
+        results.push({ success: true, item: parseResult.data, source: "json" });
+      } else {
+        results.push({
+          success: false,
+          error: `Invalid CSL-JSON: ${parseResult.error.message}`,
+          source: "json"
+        });
+      }
+    }
+    return { results };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      results: [{ success: false, error: `Failed to parse JSON: ${message}`, source: "json" }]
+    };
+  }
+}
+function parseBibtexContent(content) {
+  const parseResult = parseBibtex(content);
+  if (!parseResult.success) {
+    return {
+      results: [
+        { success: false, error: parseResult.error ?? "Failed to parse BibTeX", source: "bibtex" }
+      ]
+    };
+  }
+  if (parseResult.items.length === 0) {
+    return { results: [] };
+  }
+  return {
+    results: parseResult.items.map((item) => ({
+      success: true,
+      item,
+      source: "bibtex"
+    }))
+  };
+}
+function parseRisContent(content) {
+  const parseResult = parseRis(content);
+  if (!parseResult.success) {
+    return {
+      results: [
+        { success: false, error: parseResult.error ?? "Failed to parse RIS", source: "ris" }
+      ]
+    };
+  }
+  if (parseResult.items.length === 0) {
+    return { results: [] };
+  }
+  return {
+    results: parseResult.items.map((item) => ({
+      success: true,
+      item,
+      source: "ris"
+    }))
+  };
+}
+async function importFromContent(content, format, _options) {
+  let actualFormat;
+  if (format === "auto") {
+    actualFormat = detectByContent(content);
+    if (actualFormat === "unknown") {
+      return {
+        results: [
+          {
+            success: false,
+            error: "Cannot detect input format. Use --format to specify explicitly.",
+            source: "content"
+          }
+        ]
+      };
+    }
+  } else {
+    actualFormat = format;
+  }
+  switch (actualFormat) {
+    case "json":
+      return parseJsonContent(content);
+    case "bibtex":
+      return parseBibtexContent(content);
+    case "ris":
+      return parseRisContent(content);
+    default:
+      return {
+        results: [
+          {
+            success: false,
+            error: `Unsupported format for content parsing: ${actualFormat}`,
+            source: "content"
+          }
+        ]
+      };
+  }
+}
+async function importFromIdentifiers(identifiers, options) {
+  if (identifiers.length === 0) {
+    return { results: [] };
+  }
+  const { pmids, dois, isbns, unknowns } = classifyIdentifiers(identifiers);
+  const results = [];
+  results.push(...buildUnknownResults(unknowns));
+  const pmidResults = await fetchPmidsWithCache(pmids, options.pubmedConfig ?? {});
+  results.push(...pmidResults);
+  const doiResults = await fetchDoisWithCache(dois);
+  results.push(...doiResults);
+  const isbnResults = await fetchIsbnsWithCache(isbns);
+  results.push(...isbnResults);
+  return { results };
+}
+function looksLikeFilePath(input) {
+  const fileExtensions = [".json", ".bib", ".ris", ".txt", ".xml", ".yaml", ".yml"];
+  const lowerInput = input.toLowerCase();
+  return fileExtensions.some((ext) => lowerInput.endsWith(ext));
+}
+async function processFile(filePath, options) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    let format;
+    if (options.format && options.format !== "auto") {
+      format = options.format;
+    } else {
+      const extFormat = detectByExtension(filePath);
+      format = extFormat !== "unknown" ? extFormat : "auto";
+    }
+    const result = await importFromContent(content, format, options);
+    return result.results.map((r) => ({
+      ...r,
+      source: filePath
+    }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [
+      {
+        success: false,
+        error: `Failed to read file: ${message}`,
+        source: filePath
+      }
+    ];
+  }
+}
+async function processIdentifiers(inputs, options) {
+  const results = [];
+  const validIdentifiers = [];
+  for (const input of inputs) {
+    const isValidPmid = isPmid(input);
+    const isValidDoi = isDoi(input);
+    if (isValidPmid || isValidDoi) {
+      validIdentifiers.push(input);
+    } else {
+      const hint = looksLikeFilePath(input) ? " Hint: If this is a file path, check that the file exists." : "";
+      results.push({
+        success: false,
+        error: `Cannot interpret '${input}' as identifier (not a valid PMID or DOI).${hint}`,
+        source: input
+      });
+    }
+  }
+  if (validIdentifiers.length > 0) {
+    const fetchResult = await importFromIdentifiers(validIdentifiers, options);
+    results.push(...fetchResult.results);
+  }
+  return results;
+}
+async function importFromInputs(inputs, options) {
+  const allResults = [];
+  if (options.stdinContent?.trim()) {
+    const stdinResults = await processStdinContent(options.stdinContent, options);
+    allResults.push(...stdinResults);
+  }
+  if (inputs.length > 0) {
+    const identifiersToFetch = [];
+    for (const input of inputs) {
+      if (existsSync(input)) {
+        const fileResults = await processFile(input, options);
+        allResults.push(...fileResults);
+      } else {
+        identifiersToFetch.push(input);
+      }
+    }
+    if (identifiersToFetch.length > 0) {
+      const identifierResults = await processIdentifiers(identifiersToFetch, options);
+      allResults.push(...identifierResults);
+    }
+  }
+  return { results: allResults };
+}
+async function processStdinContent(content, options) {
+  const format = options.format || "auto";
+  if (format === "json" || format === "bibtex" || format === "ris") {
+    const result = await importFromContent(content, format);
+    return result.results.map((r) => ({
+      ...r,
+      source: r.source === "content" ? "stdin" : r.source
+    }));
+  }
+  if (format === "pmid" || format === "doi") {
+    const identifiers2 = content.split(/\s+/).filter((s) => s.length > 0);
+    return processIdentifiers(identifiers2, options);
+  }
+  const detectedFormat = detectByContent(content);
+  if (detectedFormat === "json" || detectedFormat === "bibtex" || detectedFormat === "ris") {
+    const result = await importFromContent(content, detectedFormat);
+    return result.results.map((r) => ({
+      ...r,
+      source: r.source === "content" ? "stdin" : r.source
+    }));
+  }
+  const identifiers = content.split(/\s+/).filter((s) => s.length > 0);
+  if (identifiers.length === 0) {
+    return [];
+  }
+  return processIdentifiers(identifiers, options);
+}
+async function addReferences(inputs, library, options) {
+  const added = [];
+  const failed = [];
+  const skipped = [];
+  const importOptions = buildImportOptions(options);
+  const importResult = await importFromInputs(inputs, importOptions);
+  const existingItems = await library.getAll();
+  const addedIds = /* @__PURE__ */ new Set();
+  for (const result of importResult.results) {
+    const processed = await processImportResult(
+      result,
+      existingItems,
+      addedIds,
+      options.force ?? false,
+      library
+    );
+    if (processed.type === "failed") {
+      failed.push(processed.item);
+    } else if (processed.type === "skipped") {
+      skipped.push(processed.item);
+    } else {
+      added.push(processed.item);
+    }
+  }
+  if (added.length > 0) {
+    await library.save();
+  }
+  return { added, failed, skipped };
+}
+function buildImportOptions(options) {
+  const importOptions = {};
+  if (options.format !== void 0) {
+    importOptions.format = options.format;
+  }
+  if (options.pubmedConfig !== void 0) {
+    importOptions.pubmedConfig = options.pubmedConfig;
+  }
+  if (options.stdinContent !== void 0) {
+    importOptions.stdinContent = options.stdinContent;
+  }
+  return importOptions;
+}
+async function processImportResult(result, existingItems, addedIds, force, library) {
+  if (!result.success) {
+    return { type: "failed", item: { source: result.source, error: result.error } };
+  }
+  const item = result.item;
+  if (!force) {
+    const duplicateResult = detectDuplicate(item, existingItems);
+    const existingMatch = duplicateResult.matches[0];
+    if (existingMatch) {
+      return {
+        type: "skipped",
+        item: { source: result.source, existingId: existingMatch.existing.id ?? "" }
+      };
+    }
+  }
+  const allExistingIds = /* @__PURE__ */ new Set([...existingItems.map((i) => i.id), ...addedIds]);
+  const { id, changed } = resolveIdCollision(item.id, allExistingIds);
+  const finalItem = { ...item, id };
+  await library.add(finalItem);
+  addedIds.add(id);
+  const addedItem = {
+    id,
+    title: typeof finalItem.title === "string" ? finalItem.title : ""
+  };
+  if (changed) {
+    addedItem.idChanged = true;
+    addedItem.originalId = item.id;
+  }
+  return { type: "added", item: addedItem };
+}
+function generateSuffix(index) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz";
+  let suffix = "";
+  let n = index;
+  do {
+    suffix = alphabet[n % 26] + suffix;
+    n = Math.floor(n / 26) - 1;
+  } while (n >= 0);
+  return suffix;
+}
+function resolveIdCollision(baseId, existingIds) {
+  if (!existingIds.has(baseId)) {
+    return { id: baseId, changed: false };
+  }
+  let index = 0;
+  let newId;
+  do {
+    const suffix = generateSuffix(index);
+    newId = `${baseId}${suffix}`;
+    index++;
+  } while (existingIds.has(newId));
+  return { id: newId, changed: true };
+}
+const add = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addReferences
+}, Symbol.toStringTag, { value: "Module" }));
+function formatAuthor(author) {
+  const family = author.family || "";
+  const givenInitial = author.given ? `${author.given.charAt(0)}.` : "";
+  return givenInitial ? `${family}, ${givenInitial}` : family;
+}
+function formatAuthors(authors) {
+  return authors.map(formatAuthor).join("; ");
+}
+function formatSingleReference(item) {
+  const lines = [];
+  const header = item.title ? `[${item.id}] ${item.title}` : `[${item.id}]`;
+  lines.push(header);
+  if (item.author && item.author.length > 0) {
+    lines.push(`  Authors: ${formatAuthors(item.author)}`);
+  }
+  const year = item.issued?.["date-parts"]?.[0]?.[0];
+  lines.push(`  Year: ${year || "(no year)"}`);
+  lines.push(`  Type: ${item.type}`);
+  if (item.DOI) {
+    lines.push(`  DOI: ${item.DOI}`);
+  }
+  if (item.PMID) {
+    lines.push(`  PMID: ${item.PMID}`);
+  }
+  if (item.PMCID) {
+    lines.push(`  PMCID: ${item.PMCID}`);
+  }
+  if (item.URL) {
+    lines.push(`  URL: ${item.URL}`);
+  }
+  const uuid = item.custom?.uuid || "(no uuid)";
+  lines.push(`  UUID: ${uuid}`);
+  return lines.join("\n");
+}
+function formatPretty(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  return items.map(formatSingleReference).join("\n\n");
+}
+function mapEntryType(cslType) {
+  const typeMap = {
+    article: "article",
+    "article-journal": "article",
+    "article-magazine": "article",
+    "article-newspaper": "article",
+    book: "book",
+    chapter: "inbook",
+    "paper-conference": "inproceedings",
+    thesis: "phdthesis",
+    report: "techreport",
+    webpage: "misc"
+  };
+  return typeMap[cslType] || "misc";
+}
+function formatBibtexAuthor(author) {
+  if (author.literal) {
+    return author.literal;
+  }
+  const family = author.family || "";
+  const given = author.given || "";
+  return given ? `${family}, ${given}` : family;
+}
+function formatBibtexAuthors(authors) {
+  return authors.map(formatBibtexAuthor).join(" and ");
+}
+function formatField(name, value) {
+  return `  ${name} = {${value}},`;
+}
+function addBasicFields(lines, item) {
+  if (item.title) {
+    lines.push(formatField("title", item.title));
+  }
+  if (item.author && item.author.length > 0) {
+    lines.push(formatField("author", formatBibtexAuthors(item.author)));
+  }
+  const year = item.issued?.["date-parts"]?.[0]?.[0];
+  if (year) {
+    lines.push(formatField("year", String(year)));
+  }
+}
+function addPublicationDetails(lines, item, entryType) {
+  if (item["container-title"]) {
+    if (entryType === "article") {
+      lines.push(formatField("journal", item["container-title"]));
+    } else if (entryType === "inbook" || entryType === "inproceedings") {
+      lines.push(formatField("booktitle", item["container-title"]));
+    }
+  }
+  if (item.volume) {
+    lines.push(formatField("volume", item.volume));
+  }
+  if (item.issue) {
+    lines.push(formatField("number", item.issue));
+  }
+  if (item.page) {
+    lines.push(formatField("pages", item.page));
+  }
+  if (item.publisher) {
+    lines.push(formatField("publisher", item.publisher));
+  }
+}
+function addIdentifierFields(lines, item) {
+  if (item.DOI) {
+    lines.push(formatField("doi", item.DOI));
+  }
+  if (item.URL) {
+    lines.push(formatField("url", item.URL));
+  }
+  if (item.PMID) {
+    lines.push(formatField("note", `PMID: ${item.PMID}`));
+  } else if (item.PMCID) {
+    lines.push(formatField("note", `PMCID: ${item.PMCID}`));
+  }
+}
+function formatSingleBibtexEntry(item) {
+  const entryType = mapEntryType(item.type);
+  const lines = [];
+  lines.push(`@${entryType}{${item.id},`);
+  addBasicFields(lines, item);
+  addPublicationDetails(lines, item, entryType);
+  addIdentifierFields(lines, item);
+  lines.push("}");
+  return lines.join("\n");
+}
+function formatBibtex(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  return items.map(formatSingleBibtexEntry).join("\n\n");
+}
+function formatFirstAuthor(item) {
+  if (!item.author || item.author.length === 0) {
+    return "Unknown";
+  }
+  const firstAuthor = item.author[0];
+  if (!firstAuthor) {
+    return "Unknown";
+  }
+  const family = firstAuthor.family || "Unknown";
+  const givenInitial = firstAuthor.given ? firstAuthor.given[0] : "";
+  if (givenInitial) {
+    return `${family} ${givenInitial}`;
+  }
+  return family;
+}
+function hasMultipleAuthors(item) {
+  return (item.author?.length || 0) > 1;
+}
+function extractYear(item) {
+  if (item.issued?.["date-parts"]?.[0]?.[0]) {
+    return String(item.issued["date-parts"][0][0]);
+  }
+  return "n.d.";
+}
+function getJournalAbbrev(item) {
+  const containerTitleShort = item["container-title-short"];
+  if (typeof containerTitleShort === "string") {
+    return containerTitleShort;
+  }
+  return item["container-title"] || "";
+}
+function formatVolumeIssuePage(item) {
+  const volume = item.volume;
+  const issue = item.issue;
+  const page = item.page;
+  if (!volume && !issue && !page) {
+    return "";
+  }
+  let result = "";
+  if (volume) {
+    result += volume;
+    if (issue) {
+      result += `(${issue})`;
+    }
+    if (page) {
+      result += `:${page}`;
+    }
+  } else if (page) {
+    result += page;
+  }
+  return result;
+}
+function getIdentifier(item) {
+  if (item.PMID) {
+    return `PMID:${item.PMID}`;
+  }
+  if (item.DOI) {
+    return `DOI:${item.DOI}`;
+  }
+  if (item.URL) {
+    return item.URL;
+  }
+  return "";
+}
+function formatBibliographyEntry(item) {
+  const parts = [];
+  const author = formatFirstAuthor(item);
+  const etAl = hasMultipleAuthors(item) ? " et al" : "";
+  parts.push(`${author}${etAl}.`);
+  const journal = getJournalAbbrev(item);
+  if (journal) {
+    parts.push(`${journal}.`);
+  }
+  const year = extractYear(item);
+  const volumeIssuePage = formatVolumeIssuePage(item);
+  if (volumeIssuePage) {
+    parts.push(`${year};${volumeIssuePage}.`);
+  } else {
+    parts.push(`${year}.`);
+  }
+  const identifier = getIdentifier(item);
+  if (identifier) {
+    parts.push(`${identifier}.`);
+  }
+  if (item.title) {
+    parts.push(`${item.title}.`);
+  }
+  return parts.join(" ");
+}
+function getFirstAuthorFamilyName(item) {
+  if (!item.author || item.author.length === 0) {
+    return "Unknown";
+  }
+  const firstAuthor = item.author[0];
+  if (!firstAuthor) {
+    return "Unknown";
+  }
+  return firstAuthor.family || "Unknown";
+}
+function formatInTextEntry(item) {
+  const author = getFirstAuthorFamilyName(item);
+  const etAl = hasMultipleAuthors(item) ? " et al" : "";
+  const year = extractYear(item);
+  return `${author}${etAl}, ${year}`;
+}
+function formatBibliography(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  return items.map(formatBibliographyEntry).join("\n\n");
+}
+function formatInText(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  const citations = items.map(formatInTextEntry).join("; ");
+  return `(${citations})`;
+}
+function formatBibliographyCSL(items, options) {
+  if (items.length === 0) {
+    return "";
+  }
+  const style = options.style || "apa";
+  const format = options.format || "text";
+  const locale = options.locale || "en-US";
+  try {
+    const cite2 = new Cite(items);
+    const result = cite2.format("bibliography", {
+      format,
+      template: style,
+      lang: locale
+    });
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    process.stderr.write(
+      `Warning: CSL processing failed (style: ${style}), falling back to simplified format: ${errorMessage}
+`
+    );
+    return formatBibliography(items);
+  }
+}
+function formatInTextCSL(items, options) {
+  if (items.length === 0) {
+    return "";
+  }
+  const style = options.style || "apa";
+  const format = options.format || "text";
+  const locale = options.locale || "en-US";
+  try {
+    const cite2 = new Cite(items);
+    const result = cite2.format("citation", {
+      format,
+      template: style,
+      lang: locale
+    });
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    process.stderr.write(
+      `Warning: CSL processing failed (style: ${style}), falling back to simplified format: ${errorMessage}
+`
+    );
+    return formatInText(items);
+  }
+}
+function shouldUseFallback(options) {
+  if (options.cslFile) {
+    return false;
+  }
+  if (options.style && !isBuiltinStyle(options.style)) {
+    return true;
+  }
+  return false;
+}
+function formatCitation(item, inText, options) {
+  const useFallback = shouldUseFallback(options);
+  const style = options.cslFile ?? options.style ?? "apa";
+  const locale = options.locale ?? "en-US";
+  const format = options.format ?? "text";
+  if (useFallback) {
+    return inText ? formatInText([item]) : formatBibliography([item]);
+  }
+  return inText ? formatInTextCSL([item], { style, locale, format }) : formatBibliographyCSL([item], { style, locale, format });
+}
+async function generateCitationForIdentifier(library, identifier, idType, inText, options) {
+  const item = await library.find(identifier, { idType });
+  if (!item) {
+    const lookupType = idType === "uuid" ? "UUID" : idType.toUpperCase();
+    return {
+      success: false,
+      identifier,
+      error: `Reference with ${lookupType} '${identifier}' not found`
+    };
+  }
+  const citation = formatCitation(item, inText, options);
+  return {
+    success: true,
+    identifier,
+    citation
+  };
+}
+async function citeReferences(library, options) {
+  const { identifiers, idType = "id", inText = false, style, cslFile, locale, format } = options;
+  const results = [];
+  for (const identifier of identifiers) {
+    const result = await generateCitationForIdentifier(library, identifier, idType, inText, {
+      style,
+      cslFile,
+      locale,
+      format
+    });
+    results.push(result);
+  }
+  return { results };
+}
+const cite = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  citeReferences
+}, Symbol.toStringTag, { value: "Module" }));
+async function listReferences(library, options) {
+  const format = options.format ?? "pretty";
+  const items = await library.getAll();
+  switch (format) {
+    case "json":
+      return { items: items.map((item) => JSON.stringify(item)) };
+    case "bibtex":
+      return { items: items.map((item) => formatBibtex([item])) };
+    case "ids-only":
+      return { items: items.map((item) => item.id) };
+    case "uuid":
+      return {
+        items: items.filter(
+          (item) => Boolean(item.custom?.uuid)
+        ).map((item) => item.custom.uuid)
+      };
+    default:
+      return { items: items.map((item) => formatPretty([item])) };
+  }
+}
+const list = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  listReferences
+}, Symbol.toStringTag, { value: "Module" }));
+async function removeReference(library, options) {
+  const { identifier, idType = "id" } = options;
+  const result = await library.remove(identifier, { idType });
+  if (result.removed) {
+    await library.save();
+  }
+  return result;
+}
+async function searchReferences(library, options) {
+  const format = options.format ?? "pretty";
+  const query = options.query;
+  const allItems = await library.getAll();
+  let matchedItems;
+  if (!query.trim()) {
+    matchedItems = allItems;
+  } else {
+    const tokens = tokenize(query).tokens;
+    const results = search$1(allItems, tokens);
+    const sorted = sortResults(results);
+    matchedItems = sorted.map((result) => result.reference);
+  }
+  switch (format) {
+    case "json":
+      return { items: matchedItems.map((item) => JSON.stringify(item)) };
+    case "bibtex":
+      return { items: matchedItems.map((item) => formatBibtex([item])) };
+    case "ids-only":
+      return { items: matchedItems.map((item) => item.id) };
+    case "uuid":
+      return {
+        items: matchedItems.filter(
+          (item) => Boolean(item.custom?.uuid)
+        ).map((item) => item.custom.uuid)
+      };
+    default:
+      return { items: matchedItems.map((item) => formatPretty([item])) };
+  }
+}
+const search = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  searchReferences
+}, Symbol.toStringTag, { value: "Module" }));
+function buildPubmedConfig(config) {
+  const pubmedConfig = {};
+  if (config.pubmed.email !== void 0) {
+    pubmedConfig.email = config.pubmed.email;
+  }
+  if (config.pubmed.apiKey !== void 0) {
+    pubmedConfig.apiKey = config.pubmed.apiKey;
+  }
+  return pubmedConfig;
+}
+function createAddRoute(library, config) {
+  const route = new Hono();
+  route.post("/", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    if (!body || typeof body !== "object") {
+      return c.json({ error: "Request body must be an object" }, 400);
+    }
+    const { inputs, options } = body;
+    if (!inputs || !Array.isArray(inputs) || inputs.length === 0) {
+      return c.json({ error: "inputs must be a non-empty array of strings" }, 400);
+    }
+    if (!inputs.every((input) => typeof input === "string")) {
+      return c.json({ error: "All inputs must be strings" }, 400);
+    }
+    const addOptions = {
+      force: options?.force ?? false,
+      pubmedConfig: buildPubmedConfig(config)
+    };
+    if (options?.format) {
+      addOptions.format = options.format;
+    }
+    const result = await addReferences(inputs, library, addOptions);
+    return c.json(result);
+  });
+  return route;
+}
+const CiteRequestSchema = z.object({
+  identifiers: z.array(z.string()).min(1, "identifiers must be a non-empty array"),
+  idType: z.enum(["id", "uuid", "doi", "pmid", "isbn"]).optional(),
+  inText: z.boolean().optional(),
+  style: z.string().optional(),
+  cslFile: z.string().optional(),
+  locale: z.string().optional(),
+  format: z.enum(["text", "html"]).optional()
+});
+function buildCiteOptions(body) {
+  return {
+    identifiers: body.identifiers,
+    ...body.idType !== void 0 && { idType: body.idType },
+    ...body.inText !== void 0 && { inText: body.inText },
+    ...body.style !== void 0 && { style: body.style },
+    ...body.cslFile !== void 0 && { cslFile: body.cslFile },
+    ...body.locale !== void 0 && { locale: body.locale },
+    ...body.format !== void 0 && { format: body.format }
+  };
+}
+function createCiteRoute(library) {
+  const route = new Hono();
+  route.post("/", async (c) => {
+    let rawBody;
+    try {
+      rawBody = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    const parseResult = CiteRequestSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+      const errorMessage = parseResult.error.issues[0]?.message ?? "Invalid request body";
+      return c.json({ error: errorMessage }, 400);
+    }
+    const result = await citeReferences(library, buildCiteOptions(parseResult.data));
+    return c.json(result);
+  });
+  return route;
+}
+const healthRoute = new Hono();
+healthRoute.get("/", (c) => {
+  return c.json({ status: "ok" });
+});
+const listRequestBodySchema = z.object({
+  format: z.enum(["pretty", "json", "bibtex", "ids-only", "uuid"]).optional()
+});
+function createListRoute(library) {
+  const route = new Hono();
+  route.post("/", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    const parseResult = listRequestBodySchema.safeParse(body);
+    if (!parseResult.success) {
+      return c.json({ error: "Request body must be an object" }, 400);
+    }
+    const requestBody = parseResult.data;
+    const options = {};
+    if (requestBody.format !== void 0) {
+      options.format = requestBody.format;
+    }
+    const result = await listReferences(library, options);
+    return c.json(result);
+  });
+  return route;
+}
+function createReferencesRoute(library) {
+  const route = new Hono();
+  route.get("/", async (c) => {
+    const items = await library.getAll();
+    return c.json(items);
+  });
+  route.get("/uuid/:uuid", async (c) => {
+    const uuid = c.req.param("uuid");
+    const item = await library.find(uuid, { idType: "uuid" });
+    if (!item) {
+      return c.json({ error: "Reference not found" }, 404);
+    }
+    return c.json(item);
+  });
+  route.get("/id/:id", async (c) => {
+    const id = c.req.param("id");
+    const item = await library.find(id);
+    if (!item) {
+      return c.json({ error: "Reference not found" }, 404);
+    }
+    return c.json(item);
+  });
+  route.post("/", async (c) => {
+    try {
+      const body = await c.req.json();
+      const addedItem = await library.add(body);
+      return c.json(addedItem, 201);
+    } catch (error) {
+      return c.json(
+        {
+          error: "Invalid request body",
+          details: error instanceof Error ? error.message : String(error)
+        },
+        400
+      );
+    }
+  });
+  route.put("/uuid/:uuid", async (c) => {
+    const uuid = c.req.param("uuid");
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    if (!body || typeof body !== "object") {
+      return c.json({ error: "Request body must be an object" }, 400);
+    }
+    const { updates, onIdCollision } = body;
+    if (!updates || typeof updates !== "object") {
+      return c.json({ error: "Request body must contain 'updates' object" }, 400);
+    }
+    const result = await updateReference(library, {
+      identifier: uuid,
+      idType: "uuid",
+      updates,
+      onIdCollision: onIdCollision ?? "suffix"
+    });
+    if (!result.updated) {
+      const status = result.idCollision ? 409 : 404;
+      return c.json(result, status);
+    }
+    return c.json(result);
+  });
+  route.put("/id/:id", async (c) => {
+    const id = c.req.param("id");
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    if (!body || typeof body !== "object") {
+      return c.json({ error: "Request body must be an object" }, 400);
+    }
+    const { updates, onIdCollision } = body;
+    if (!updates || typeof updates !== "object") {
+      return c.json({ error: "Request body must contain 'updates' object" }, 400);
+    }
+    const result = await updateReference(library, {
+      identifier: id,
+      updates,
+      onIdCollision: onIdCollision ?? "suffix"
+    });
+    if (!result.updated) {
+      const status = result.idCollision ? 409 : 404;
+      return c.json(result, status);
+    }
+    return c.json(result);
+  });
+  route.delete("/uuid/:uuid", async (c) => {
+    const uuid = c.req.param("uuid");
+    const result = await removeReference(library, {
+      identifier: uuid,
+      idType: "uuid"
+    });
+    if (!result.removed) {
+      return c.json(result, 404);
+    }
+    return c.json(result);
+  });
+  route.delete("/id/:id", async (c) => {
+    const id = c.req.param("id");
+    const result = await removeReference(library, {
+      identifier: id
+    });
+    if (!result.removed) {
+      return c.json(result, 404);
+    }
+    return c.json(result);
+  });
+  return route;
+}
+const searchRequestBodySchema = z.object({
+  query: z.string(),
+  format: z.enum(["pretty", "json", "bibtex", "ids-only", "uuid"]).optional()
+});
+function createSearchRoute(library) {
+  const route = new Hono();
+  route.post("/", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    const parseResult = searchRequestBodySchema.safeParse(body);
+    if (!parseResult.success) {
+      return c.json({ error: "Invalid request body" }, 400);
+    }
+    const requestBody = parseResult.data;
+    const options = {
+      query: requestBody.query
+    };
+    if (requestBody.format !== void 0) {
+      options.format = requestBody.format;
+    }
+    const result = await searchReferences(library, options);
+    return c.json(result);
+  });
+  return route;
+}
+function createServer(library, config) {
+  const app = new Hono();
+  app.route("/health", healthRoute);
+  const referencesRoute = createReferencesRoute(library);
+  app.route("/api/references", referencesRoute);
+  const addRoute = createAddRoute(library, config);
+  app.route("/api/add", addRoute);
+  const citeRoute = createCiteRoute(library);
+  app.route("/api/cite", citeRoute);
+  const listRoute = createListRoute(library);
+  app.route("/api/list", listRoute);
+  const searchRoute = createSearchRoute(library);
+  app.route("/api/search", searchRoute);
+  return app;
+}
+async function startServerWithFileWatcher(libraryPath, config) {
+  const library = await Library.load(libraryPath);
+  const app = createServer(library, config);
+  const fileWatcher = new FileWatcher(libraryPath, {
+    debounceMs: config.watch.debounceMs,
+    maxRetries: config.watch.maxRetries,
+    retryDelayMs: config.watch.retryIntervalMs,
+    pollIntervalMs: config.watch.pollIntervalMs
+  });
+  fileWatcher.on("change", () => {
+    library.reload().catch((error) => {
+      console.error("Failed to reload library:", error);
+    });
+  });
+  await fileWatcher.start();
+  const dispose = async () => {
+    fileWatcher.close();
+  };
+  return {
+    app,
+    library,
+    fileWatcher,
+    dispose
+  };
+}
+export {
+  BUILTIN_STYLES as B,
+  addReferences as a,
+  startServerWithFileWatcher as b,
+  citeReferences as c,
+  createServer as d,
+  add as e,
+  cite as f,
+  list as g,
+  search as h,
+  listReferences as l,
+  removeReference as r,
+  searchReferences as s,
+  updateReference as u
+};
+//# sourceMappingURL=index-Bl_mOQRe.js.map