@ncukondo/reference-manager 0.20.0 → 0.22.0

package/dist/chunks/index-DrZawbND.js

@@ -1,2082 +0,0 @@
-import { Hono } from "hono";
-import { g as CslItemSchema, f as detectDuplicate, k as generateId, a as sortOrderSchema, b as sortFieldSchema, p as pickDefined, t as tokenize, s as search$1, e as sortResults, v as searchSortFieldSchema, L as Library, F as FileWatcher } from "./file-watcher-CrsNHUpz.js";
-import * as fs from "node:fs";
-import { existsSync, readFileSync } from "node:fs";
-import { Cite, plugins } 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 * as path from "node:path";
-import path__default, { join } from "node:path";
-import "@citation-js/plugin-csl";
-import { unlink, rmdir } from "node:fs/promises";
-const RESERVED_ROLES = ["fulltext", "supplement", "notes", "draft"];
-function isReservedRole(role) {
-  return RESERVED_ROLES.includes(role);
-}
-function getExtension(filename) {
-  const ext = path__default.extname(filename);
-  return ext.startsWith(".") ? ext.slice(1).toLowerCase() : ext.toLowerCase();
-}
-function isValidFulltextFiles(files) {
-  const fulltextFiles = files.filter((f) => f.role === "fulltext");
-  if (fulltextFiles.length > 2) {
-    return false;
-  }
-  if (fulltextFiles.length <= 1) {
-    return true;
-  }
-  const extensions = fulltextFiles.map((f) => getExtension(f.filename));
-  const pdfCount = extensions.filter((ext) => ext === "pdf").length;
-  const mdCount = extensions.filter((ext) => ext === "md").length;
-  return pdfCount === 1 && mdCount === 1;
-}
-const FULLTEXT_ROLE = "fulltext";
-function formatToExtension(format) {
-  return format === "markdown" ? "md" : format;
-}
-function extensionToFormat(ext) {
-  const normalized = ext.toLowerCase();
-  if (normalized === "pdf") return "pdf";
-  if (normalized === "md" || normalized === "markdown") return "markdown";
-  return void 0;
-}
-function findFulltextFile(attachments, format) {
-  if (!attachments?.files) {
-    return void 0;
-  }
-  const targetExt = formatToExtension(format);
-  return attachments.files.find((file) => {
-    if (file.role !== FULLTEXT_ROLE) {
-      return false;
-    }
-    const fileExt = getExtension(file.filename);
-    return fileExt === targetExt;
-  });
-}
-function findFulltextFiles(attachments) {
-  if (!attachments?.files) {
-    return [];
-  }
-  return attachments.files.filter((file) => file.role === FULLTEXT_ROLE);
-}
-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 registerCustomStyle(styleName, styleXml) {
-  if (!styleXml.includes("<style") || !styleXml.includes("</style>")) {
-    throw new Error(
-      "Invalid CSL file: Missing <style> element. The file may be malformed or not a valid CSL style."
-    );
-  }
-  const hasCitation = styleXml.includes("<citation") || styleXml.includes("<citation>");
-  const hasBibliography = styleXml.includes("<bibliography") || styleXml.includes("<bibliography>");
-  if (!hasCitation && !hasBibliography) {
-    throw new Error(
-      "Invalid CSL file: Missing <citation> or <bibliography> section. A valid CSL style must define at least one of these sections."
-    );
-  }
-  try {
-    const config = plugins.config.get("@csl");
-    config.templates.add(styleName, styleXml);
-    return styleName;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to register CSL style '${styleName}': ${message}`);
-  }
-}
-function formatBibliographyCSL(items, options) {
-  if (items.length === 0) {
-    return "";
-  }
-  let style = options.style || "apa";
-  const format = options.format || "text";
-  const locale = options.locale || "en-US";
-  if (options.styleXml) {
-    style = registerCustomStyle(style, options.styleXml);
-  }
-  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 "";
-  }
-  let style = options.style || "apa";
-  const format = options.format || "text";
-  const locale = options.locale || "en-US";
-  if (options.styleXml) {
-    style = registerCustomStyle(style, options.styleXml);
-  }
-  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 getCreatedAt(item) {
-  const createdAt = item.custom?.created_at;
-  if (!createdAt) return 0;
-  return new Date(createdAt).getTime();
-}
-function getUpdatedAt(item) {
-  const timestamp = item.custom?.timestamp;
-  if (timestamp) return new Date(timestamp).getTime();
-  return getCreatedAt(item);
-}
-function getPublishedDate(item) {
-  const dateParts = item.issued?.["date-parts"]?.[0];
-  if (!dateParts || dateParts.length === 0) return 0;
-  const year = dateParts[0] ?? 0;
-  const month = dateParts[1] ?? 1;
-  const day = dateParts[2] ?? 1;
-  return new Date(year, month - 1, day).getTime();
-}
-function getAuthorName(item) {
-  const firstAuthor = item.author?.[0];
-  if (!firstAuthor) return "Anonymous";
-  return firstAuthor.family ?? firstAuthor.literal ?? "Anonymous";
-}
-function getTitle(item) {
-  return item.title ?? "";
-}
-function getSortValue(item, field) {
-  switch (field) {
-    case "created":
-      return getCreatedAt(item);
-    case "updated":
-      return getUpdatedAt(item);
-    case "published":
-      return getPublishedDate(item);
-    case "author":
-      return getAuthorName(item).toLowerCase();
-    case "title":
-      return getTitle(item).toLowerCase();
-  }
-}
-function compareValues(a, b, order) {
-  const multiplier = order === "desc" ? -1 : 1;
-  if (typeof a === "number" && typeof b === "number") {
-    return (a - b) * multiplier;
-  }
-  const strA = String(a);
-  const strB = String(b);
-  return strA.localeCompare(strB) * multiplier;
-}
-function sortReferences(items, sort, order) {
-  return [...items].sort((a, b) => {
-    const aValue = getSortValue(a, sort);
-    const bValue = getSortValue(b, sort);
-    const primaryCompare = compareValues(aValue, bValue, order);
-    if (primaryCompare !== 0) return primaryCompare;
-    const aCreated = getCreatedAt(a);
-    const bCreated = getCreatedAt(b);
-    const createdCompare = bCreated - aCreated;
-    if (createdCompare !== 0) return createdCompare;
-    return a.id.localeCompare(b.id);
-  });
-}
-function paginate(items, options) {
-  const offset = options.offset ?? 0;
-  const limit = options.limit ?? 0;
-  if (limit < 0) {
-    throw new Error("limit must be non-negative");
-  }
-  if (offset < 0) {
-    throw new Error("offset must be non-negative");
-  }
-  const isUnlimited = limit === 0;
-  const afterOffset = items.slice(offset);
-  const paginatedItems = isUnlimited ? afterOffset : afterOffset.slice(0, limit);
-  let nextOffset = null;
-  if (!isUnlimited && paginatedItems.length > 0) {
-    const nextPosition = offset + paginatedItems.length;
-    if (nextPosition < items.length) {
-      nextOffset = nextPosition;
-    }
-  }
-  return {
-    items: paginatedItems,
-    nextOffset
-  };
-}
-const BUILTIN_STYLES = ["apa", "vancouver", "harvard"];
-function isBuiltinStyle(styleName) {
-  return BUILTIN_STYLES.includes(styleName);
-}
-function expandTilde(filePath) {
-  if (filePath.startsWith("~/")) {
-    const home = process.env.HOME || process.env.USERPROFILE || "";
-    return path.join(home, filePath.slice(2));
-  }
-  return filePath;
-}
-function loadCSLStyleFile(stylePath) {
-  return fs.readFileSync(stylePath, "utf-8");
-}
-function resolveStyle(options) {
-  const { cslFile, style, cslDirectory, defaultStyle } = options;
-  if (cslFile) {
-    if (!fs.existsSync(cslFile)) {
-      throw new Error(`CSL file '${cslFile}' not found`);
-    }
-    const styleXml = loadCSLStyleFile(cslFile);
-    const styleName = path.basename(cslFile, ".csl");
-    return {
-      type: "custom",
-      styleName,
-      styleXml
-    };
-  }
-  const styleToResolve = style || defaultStyle || "apa";
-  if (isBuiltinStyle(styleToResolve)) {
-    return {
-      type: "builtin",
-      styleName: styleToResolve
-    };
-  }
-  if (cslDirectory) {
-    const directories = Array.isArray(cslDirectory) ? cslDirectory : [cslDirectory];
-    for (const dir of directories) {
-      const expandedDir = expandTilde(dir);
-      const stylePath = path.join(expandedDir, `${styleToResolve}.csl`);
-      if (fs.existsSync(stylePath)) {
-        const styleXml = loadCSLStyleFile(stylePath);
-        return {
-          type: "custom",
-          styleName: styleToResolve,
-          styleXml
-        };
-      }
-    }
-  }
-  if (defaultStyle && isBuiltinStyle(defaultStyle)) {
-    return {
-      type: "builtin",
-      styleName: defaultStyle
-    };
-  }
-  return {
-    type: "builtin",
-    styleName: "apa"
-  };
-}
-function getFulltextAttachmentTypes(item) {
-  const types = [];
-  const attachments = item.custom?.attachments;
-  const fulltextFiles = findFulltextFiles(attachments);
-  for (const file of fulltextFiles) {
-    const ext = file.filename.split(".").pop()?.toLowerCase();
-    const format = ext ? extensionToFormat(ext) : void 0;
-    if (format && !types.includes(format)) {
-      types.push(format);
-    }
-  }
-  return types;
-}
-async function deleteFulltextFiles(item, fulltextDirectory) {
-  const filesToDelete = [];
-  const attachments = item.custom?.attachments;
-  if (attachments?.directory) {
-    const fulltextFiles = findFulltextFiles(attachments);
-    for (const file of fulltextFiles) {
-      filesToDelete.push(join(fulltextDirectory, attachments.directory, file.filename));
-    }
-  }
-  for (const filePath of filesToDelete) {
-    try {
-      await unlink(filePath);
-    } catch {
-    }
-  }
-  if (attachments?.directory) {
-    try {
-      const dirPath = join(fulltextDirectory, attachments.directory);
-      await rmdir(dirPath);
-    } catch {
-    }
-  }
-}
-async function removeReference(library, options) {
-  const { identifier, idType = "id", fulltextDirectory, deleteFulltext = false } = options;
-  const result = await library.remove(identifier, { idType });
-  if (!result.removed || !result.removedItem) {
-    return { removed: false };
-  }
-  let deletedFulltextTypes;
-  if (deleteFulltext && fulltextDirectory) {
-    deletedFulltextTypes = getFulltextAttachmentTypes(result.removedItem);
-    if (deletedFulltextTypes.length > 0) {
-      await deleteFulltextFiles(result.removedItem, fulltextDirectory);
-    }
-  }
-  await library.save();
-  return {
-    removed: true,
-    removedItem: result.removedItem,
-    ...deletedFulltextTypes && deletedFulltextTypes.length > 0 && { deletedFulltextTypes }
-  };
-}
-const remove = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getFulltextAttachmentTypes,
-  removeReference
-}, Symbol.toStringTag, { value: "Module" }));
-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",
-  ".nbib": "nbib"
-};
-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";
-  }
-  if (trimmed.startsWith("PMID-")) {
-    return "nbib";
-  }
-  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}`,
-      reason: "validation_error"
-    };
-  }
-  return {
-    pmid,
-    success: false,
-    error: `PMID ${pmid} not found`,
-    reason: "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,
-        reason: "fetch_error"
-      }));
-    }
-    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,
-      reason: "fetch_error"
-    }));
-  }
-}
-async function fetchDoi(doi) {
-  if (!DOI_PATTERN.test(doi)) {
-    return {
-      success: false,
-      error: `Invalid DOI format: ${doi}`,
-      reason: "validation_error"
-    };
-  }
-  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}`,
-        reason: "not_found"
-      };
-    }
-    const parseResult = CslItemSchema.safeParse(rawItems[0]);
-    if (!parseResult.success) {
-      return {
-        success: false,
-        error: `Invalid CSL-JSON data for DOI ${doi}: ${parseResult.error.message}`,
-        reason: "validation_error"
-      };
-    }
-    return { success: true, item: parseResult.data };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: errorMsg,
-      reason: "fetch_error"
-    };
-  }
-}
-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}`,
-      reason: "validation_error"
-    };
-  }
-  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}`,
-        reason: "not_found"
-      };
-    }
-    const parseResult = CslItemSchema.safeParse(rawItems[0]);
-    if (!parseResult.success) {
-      return {
-        success: false,
-        error: `Invalid CSL-JSON data for ISBN ${isbn}: ${parseResult.error.message}`,
-        reason: "validation_error"
-      };
-    }
-    return { success: true, item: parseResult.data };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: errorMsg,
-      reason: "fetch_error"
-    };
-  }
-}
-function parseBibtex(content) {
-  return parseWithCitationJs(content, "bibtex");
-}
-function parseRis(content) {
-  return parseWithCitationJs(content, "ris");
-}
-const NBIB_TO_RIS_TAG_MAP = {
-  PMID: "AN",
-  // PubMed ID -> Accession Number
-  TI: "TI",
-  // Title -> Title
-  FAU: "AU",
-  // Full Author -> Author
-  AU: "AU",
-  // Author -> Author (short form, use FAU when available)
-  JT: "JO",
-  // Journal Title -> Journal Name
-  TA: "JA",
-  // Title Abbreviation -> Journal Abbreviation
-  AB: "AB",
-  // Abstract -> Abstract
-  VI: "VL",
-  // Volume -> Volume
-  IP: "IS",
-  // Issue/Part -> Issue Number
-  PG: "SP",
-  // Pagination -> Start Page (includes range)
-  DP: "PY",
-  // Date of Publication -> Publication Year
-  LA: "LA",
-  // Language -> Language
-  MH: "KW",
-  // MeSH Headings -> Keywords
-  OT: "KW",
-  // Other Terms -> Keywords
-  AD: "AD",
-  // Affiliation/Address -> Author Address
-  IS: "SN",
-  // ISSN -> Serial Number
-  PT: "TY"
-  // Publication Type -> Type of Reference
-};
-const NBIB_PUBLICATION_TYPE_MAP = {
-  "Journal Article": "JOUR",
-  Review: "JOUR",
-  Book: "BOOK",
-  "Book Chapter": "CHAP",
-  "Conference Paper": "CPAPER",
-  Thesis: "THES",
-  Report: "RPRT"
-};
-function parseNbibEntry(entry) {
-  const result = [];
-  const lines = entry.split("\n");
-  let currentTag = "";
-  let currentValue = "";
-  for (const line of lines) {
-    const tagMatch = line.match(/^([A-Z]{2,4})\s*-\s*(.*)$/);
-    if (tagMatch) {
-      if (currentTag) {
-        result.push({ tag: currentTag, value: currentValue.trim() });
-      }
-      currentTag = tagMatch[1] ?? "";
-      currentValue = tagMatch[2] ?? "";
-    } else if (currentTag && line.match(/^\s+/)) {
-      currentValue += ` ${line.trim()}`;
-    }
-  }
-  if (currentTag) {
-    result.push({ tag: currentTag, value: currentValue.trim() });
-  }
-  return result;
-}
-function convertNbibTagToRisLine(tag, value) {
-  if (tag === "AID" && value.includes("[doi]")) {
-    const doi = value.replace(/\s*\[doi\].*$/, "").trim();
-    return { line: `DO  - ${doi}` };
-  }
-  if (tag === "AID" && value.includes("[pii]")) {
-    const pii = value.replace(/\s*\[pii\].*$/, "").trim();
-    return { line: `C1  - ${pii}` };
-  }
-  const risTag = NBIB_TO_RIS_TAG_MAP[tag];
-  if (!risTag) {
-    return null;
-  }
-  if (risTag === "PY") {
-    const yearMatch = value.match(/^(\d{4})/);
-    return yearMatch ? { line: `PY  - ${yearMatch[1]}` } : null;
-  }
-  if (risTag === "TY") {
-    const risType = NBIB_PUBLICATION_TYPE_MAP[value] || "JOUR";
-    return { line: `TY  - ${risType}`, isType: true };
-  }
-  return { line: `${risTag}  - ${value}` };
-}
-function convertSingleNbibEntryToRis(entry) {
-  const parsed = parseNbibEntry(entry);
-  if (parsed.length === 0) {
-    return "";
-  }
-  const risLines = [];
-  let hasType = false;
-  for (const { tag, value } of parsed) {
-    const converted = convertNbibTagToRisLine(tag, value);
-    if (!converted) {
-      continue;
-    }
-    if (converted.isType) {
-      risLines.unshift(converted.line);
-      hasType = true;
-    } else {
-      risLines.push(converted.line);
-    }
-  }
-  if (!hasType) {
-    risLines.unshift("TY  - JOUR");
-  }
-  risLines.push("ER  -");
-  return risLines.join("\n");
-}
-function convertNbibToRis(content) {
-  const trimmed = content.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const entries = trimmed.split(/\n\s*\n/).filter((e) => e.trim());
-  const risEntries = entries.map((entry) => convertSingleNbibEntryToRis(entry)).filter(Boolean);
-  return risEntries.join("\n\n");
-}
-function parseNbib(content) {
-  const trimmed = content.trim();
-  if (!trimmed) {
-    return { success: true, items: [] };
-  }
-  const risContent = convertNbibToRis(trimmed);
-  if (!risContent) {
-    return {
-      success: false,
-      items: [],
-      error: "Failed to convert NBIB to RIS: No valid entries found"
-    };
-  }
-  return parseRis(risContent);
-}
-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,
-    reason: "validation_error"
-  }));
-}
-function clearItemId(item) {
-  const { id: _ignored, ...rest } = item;
-  return { ...rest, id: "" };
-}
-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: clearItemId(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: clearItemId(fetchResult.item),
-          source: fetchResult.pmid
-        });
-      } else {
-        results.push({
-          success: false,
-          error: fetchResult.error,
-          source: fetchResult.pmid,
-          reason: fetchResult.reason
-        });
-      }
-    }
-  }
-  return results;
-}
-async function fetchDoisWithCache(dois) {
-  const results = [];
-  for (const doi of dois) {
-    const cached = getDoiFromCache(doi);
-    if (cached) {
-      results.push({ success: true, item: clearItemId(cached), source: doi });
-      continue;
-    }
-    const fetchResult = await fetchDoi(doi);
-    if (fetchResult.success) {
-      cacheDoiResult(doi, fetchResult.item);
-      results.push({ success: true, item: clearItemId(fetchResult.item), source: doi });
-    } else {
-      results.push({
-        success: false,
-        error: fetchResult.error,
-        source: doi,
-        reason: fetchResult.reason
-      });
-    }
-  }
-  return results;
-}
-async function fetchIsbnsWithCache(isbns) {
-  const results = [];
-  for (const isbn of isbns) {
-    const cached = getIsbnFromCache(isbn);
-    if (cached) {
-      results.push({ success: true, item: clearItemId(cached), source: isbn });
-      continue;
-    }
-    const fetchResult = await fetchIsbn(isbn);
-    if (fetchResult.success) {
-      cacheIsbnResult(isbn, fetchResult.item);
-      results.push({ success: true, item: clearItemId(fetchResult.item), source: isbn });
-    } else {
-      results.push({
-        success: false,
-        error: fetchResult.error,
-        source: isbn,
-        reason: fetchResult.reason
-      });
-    }
-  }
-  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",
-          reason: "validation_error"
-        });
-      }
-    }
-    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",
-          reason: "parse_error"
-        }
-      ]
-    };
-  }
-}
-function parseBibtexContent(content) {
-  const parseResult = parseBibtex(content);
-  if (!parseResult.success) {
-    return {
-      results: [
-        {
-          success: false,
-          error: parseResult.error ?? "Failed to parse BibTeX",
-          source: "bibtex",
-          reason: "parse_error"
-        }
-      ]
-    };
-  }
-  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",
-          reason: "parse_error"
-        }
-      ]
-    };
-  }
-  if (parseResult.items.length === 0) {
-    return { results: [] };
-  }
-  return {
-    results: parseResult.items.map((item) => ({
-      success: true,
-      item,
-      source: "ris"
-    }))
-  };
-}
-function parseNbibContent(content) {
-  const parseResult = parseNbib(content);
-  if (!parseResult.success) {
-    return {
-      results: [
-        {
-          success: false,
-          error: parseResult.error ?? "Failed to parse NBIB",
-          source: "nbib",
-          reason: "parse_error"
-        }
-      ]
-    };
-  }
-  if (parseResult.items.length === 0) {
-    return { results: [] };
-  }
-  return {
-    results: parseResult.items.map((item) => ({
-      success: true,
-      item,
-      source: "nbib"
-    }))
-  };
-}
-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",
-            reason: "validation_error"
-          }
-        ]
-      };
-    }
-  } else {
-    actualFormat = format;
-  }
-  switch (actualFormat) {
-    case "json":
-      return parseJsonContent(content);
-    case "bibtex":
-      return parseBibtexContent(content);
-    case "ris":
-      return parseRisContent(content);
-    case "nbib":
-      return parseNbibContent(content);
-    default:
-      return {
-        results: [
-          {
-            success: false,
-            error: `Unsupported format for content parsing: ${actualFormat}`,
-            source: "content",
-            reason: "validation_error"
-          }
-        ]
-      };
-  }
-}
-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,
-        reason: "fetch_error"
-      }
-    ];
-  }
-}
-async function processIdentifiers(inputs, options) {
-  const results = [];
-  const validIdentifiers = [];
-  for (const input of inputs) {
-    const isValidPmid = isPmid(input);
-    const isValidDoi = isDoi(input);
-    const isValidIsbn = isIsbn(input);
-    if (isValidPmid || isValidDoi || isValidIsbn) {
-      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, DOI, or ISBN).${hint}`,
-        source: input,
-        reason: "validation_error"
-      });
-    }
-  }
-  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" || format === "nbib") {
-    const result = await importFromContent(content, format);
-    return result.results.map((r) => ({
-      ...r,
-      source: r.source === "content" ? "stdin" : r.source
-    }));
-  }
-  if (format === "pmid" || format === "doi" || format === "isbn") {
-    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" || detectedFormat === "nbib") {
-    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, reason: result.reason }
-    };
-  }
-  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 ?? "",
-          duplicateType: existingMatch.type
-        }
-      };
-    }
-  }
-  const allExistingIds = /* @__PURE__ */ new Set([...existingItems.map((i) => i.id), ...addedIds]);
-  const originalId = item.id?.trim() || "";
-  const hasOriginalId = originalId.length > 0;
-  const baseId = hasOriginalId ? originalId : generateId(item);
-  const { id, changed } = resolveIdCollision(baseId, allExistingIds);
-  const finalItem = { ...item, id };
-  const addedToLibrary = await library.add(finalItem);
-  addedIds.add(id);
-  const uuid = addedToLibrary.custom?.uuid ?? "";
-  const addedItem = {
-    source: result.source,
-    id,
-    uuid,
-    title: typeof finalItem.title === "string" ? finalItem.title : ""
-  };
-  if (hasOriginalId && changed) {
-    addedItem.idChanged = true;
-    addedItem.originalId = originalId;
-  }
-  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 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;
-}
-function shouldUseFallback(style, hasCustomXml) {
-  if (hasCustomXml) {
-    return false;
-  }
-  if (style && !isBuiltinStyle(style)) {
-    return true;
-  }
-  return false;
-}
-function formatCitation(item, inText, options) {
-  const useFallback = shouldUseFallback(options.style, !!options.styleXml);
-  const style = options.style ?? "apa";
-  const locale = options.locale ?? "en-US";
-  const format = options.format ?? "text";
-  const styleXml = options.styleXml;
-  if (useFallback) {
-    return inText ? formatInText([item]) : formatBibliography([item]);
-  }
-  const formatOptions = { style, locale, format, ...styleXml && { styleXml } };
-  return inText ? formatInTextCSL([item], formatOptions) : formatBibliographyCSL([item], formatOptions);
-}
-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,
-    defaultStyle,
-    cslDirectory,
-    locale,
-    format
-  } = options;
-  const results = [];
-  const resolution = resolveStyle({
-    ...cslFile !== void 0 && { cslFile },
-    ...style !== void 0 && { style },
-    ...defaultStyle !== void 0 && { defaultStyle },
-    ...cslDirectory !== void 0 && { cslDirectory }
-  });
-  for (const identifier of identifiers) {
-    const result = await generateCitationForIdentifier(library, identifier, idType, inText, {
-      style: resolution.styleName,
-      styleXml: resolution.styleXml,
-      locale,
-      format
-    });
-    results.push(result);
-  }
-  return { results };
-}
-const cite = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  citeReferences
-}, Symbol.toStringTag, { value: "Module" }));
-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" });
-});
-async function listReferences(library, options) {
-  const sort = options.sort ?? "updated";
-  const order = options.order ?? "desc";
-  const limit = options.limit ?? 0;
-  const offset = options.offset ?? 0;
-  const allItems = await library.getAll();
-  const total = allItems.length;
-  const sorted = sortReferences(allItems, sort, order);
-  const { items: paginatedItems, nextOffset } = paginate(sorted, { limit, offset });
-  return {
-    items: paginatedItems,
-    total,
-    limit,
-    offset,
-    nextOffset
-  };
-}
-const list = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  listReferences
-}, Symbol.toStringTag, { value: "Module" }));
-const listRequestBodySchema = z.object({
-  sort: sortFieldSchema.optional(),
-  order: sortOrderSchema.optional(),
-  limit: z.number().int().min(0).optional(),
-  offset: z.number().int().min(0).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) {
-      const errorMessage = parseResult.error.issues[0]?.message ?? "Invalid request body";
-      return c.json({ error: errorMessage }, 400);
-    }
-    const requestBody = parseResult.data;
-    const options = pickDefined(requestBody, [
-      "sort",
-      "order",
-      "limit",
-      "offset"
-    ]);
-    const result = await listReferences(library, options);
-    return c.json(result);
-  });
-  return route;
-}
-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.errorType) {
-      result2.errorType = updateResult.errorType;
-    }
-    if (updateResult.item) {
-      result2.item = updateResult.item;
-    }
-    if (updateResult.idChanged && updateResult.newId) {
-      result2.idChanged = true;
-      result2.newId = updateResult.newId;
-    }
-    return result2;
-  }
-  await library.save();
-  const result = { updated: true };
-  if (updateResult.item) {
-    result.item = updateResult.item;
-  }
-  if (updateResult.oldItem) {
-    result.oldItem = updateResult.oldItem;
-  }
-  if (updateResult.idChanged && updateResult.newId) {
-    result.idChanged = true;
-    result.newId = updateResult.newId;
-  }
-  return result;
-}
-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.errorType === "id_collision" ? 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.errorType === "id_collision" ? 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;
-}
-async function searchReferences(library, options) {
-  const query = options.query;
-  const sort = options.sort ?? "updated";
-  const order = options.order ?? "desc";
-  const limit = options.limit ?? 0;
-  const offset = options.offset ?? 0;
-  const allItems = await library.getAll();
-  let matchedItems;
-  if (!query.trim()) {
-    matchedItems = allItems;
-  } else {
-    const tokens = tokenize(query).tokens;
-    const results = search$1(allItems, tokens);
-    if (sort === "relevance") {
-      const sorted2 = sortResults(results);
-      matchedItems = order === "desc" ? sorted2.map((r) => r.reference) : sorted2.map((r) => r.reference).reverse();
-    } else {
-      matchedItems = results.map((r) => r.reference);
-    }
-  }
-  const total = matchedItems.length;
-  let sorted;
-  if (sort === "relevance") {
-    sorted = matchedItems;
-  } else {
-    sorted = sortReferences(matchedItems, sort, order);
-  }
-  const { items: paginatedItems, nextOffset } = paginate(sorted, { limit, offset });
-  return {
-    items: paginatedItems,
-    total,
-    limit,
-    offset,
-    nextOffset
-  };
-}
-const search = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  searchReferences
-}, Symbol.toStringTag, { value: "Module" }));
-const searchRequestBodySchema = z.object({
-  query: z.string(),
-  sort: searchSortFieldSchema.optional(),
-  order: sortOrderSchema.optional(),
-  limit: z.number().int().min(0).optional(),
-  offset: z.number().int().min(0).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) {
-      const errorMessage = parseResult.error.issues[0]?.message ?? "Invalid request body";
-      return c.json({ error: errorMessage }, 400);
-    }
-    const requestBody = parseResult.data;
-    const options = {
-      query: requestBody.query,
-      ...pickDefined(requestBody, ["sort", "order", "limit", "offset"])
-    };
-    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,
-  FULLTEXT_ROLE as F,
-  RESERVED_ROLES as R,
-  isReservedRole as a,
-  formatToExtension as b,
-  findFulltextFiles as c,
-  findFulltextFile as d,
-  extensionToFormat as e,
-  formatBibliographyCSL as f,
-  getExtension as g,
-  getFulltextAttachmentTypes as h,
-  isValidFulltextFiles as i,
-  createServer as j,
-  add as k,
-  cite as l,
-  list as m,
-  search as n,
-  remove as r,
-  startServerWithFileWatcher as s
-};
-//# sourceMappingURL=index-DrZawbND.js.map