@ncukondo/reference-manager 0.27.1 → 0.28.0

package/dist/chunks/{index-DUpYvm-W.js → index-T-edKSzd.js}

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { h as CslItemSchema, g as detectDuplicate, m as generateId, a as sortOrderSchema, b as sortFieldSchema, p as pickDefined, t as tokenize, s as search$1, f as sortResults, y as searchSortFieldSchema, L as Library, F as FileWatcher } from "./file-watcher-Dlx0PolG.js";
+import { h as CslItemSchema, g as detectDuplicate, m as generateId, a as sortOrderSchema, b as sortFieldSchema, p as pickDefined, t as tokenize, s as search$1, f as sortResults, y as searchSortFieldSchema, L as Library, F as FileWatcher } from "./file-watcher-CWHg1yol.js";
 import * as fs from "node:fs";
 import { mkdtempSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { Cite, plugins } from "@citation-js/core";
@@ -770,12 +770,14 @@ async function checkUnpaywallDetailed(doi, email) {
 const DEFAULT_SOURCE_ORDER = ["pmc", "arxiv", "unpaywall", "core"];
 function checkArxivSource(article) {
   if (!article.arxivId)
-    return void 0;
+    return { skipped: "no arXiv ID available" };
   return checkArxiv(article.arxivId);
 }
 async function checkCoreSource(article, config) {
-  if (!config.coreApiKey || !article.doi)
-    return void 0;
+  if (!config.coreApiKey)
+    return { skipped: "coreApiKey not configured" };
+  if (!article.doi)
+    return { skipped: "no DOI available" };
   return await checkCore(article.doi, config.coreApiKey);
 }
 const sourceCheckers = {
@@ -819,9 +821,16 @@ async function enrichArticleIds(article, config) {
   return { enriched: article, discoveredIds };
 }
 async function checkUnpaywallSource(enriched, config, state) {
-  if (!config.unpaywallEmail || !enriched.doi)
+  if (!config.unpaywallEmail) {
+    state.skipped.push({ source: "unpaywall", reason: "unpaywallEmail not configured" });
     return;
+  }
+  if (!enriched.doi) {
+    state.skipped.push({ source: "unpaywall", reason: "no DOI available" });
+    return;
+  }
   state.sourcesChecked++;
+  state.checkedSources.push("unpaywall");
   try {
     const detailed = await checkUnpaywallDetailed(enriched.doi, config.unpaywallEmail);
     if (!detailed)
@@ -835,14 +844,17 @@ async function checkUnpaywallSource(enriched, config, state) {
   }
 }
 async function checkPmcSourceWithIds(enriched, state, discoveredIds) {
-  if (!enriched.pmid && !enriched.pmcid)
+  if (!enriched.pmid && !enriched.pmcid) {
+    state.skipped.push({ source: "pmc", reason: "no PMCID or PMID available" });
     return;
+  }
   const ids = {};
   if (enriched.pmid)
     ids.pmid = enriched.pmid;
   if (enriched.pmcid)
     ids.pmcid = enriched.pmcid;
   state.sourcesChecked++;
+  state.checkedSources.push("pmc");
   try {
     const result = await checkPmc(ids);
     if (!result)
@@ -860,9 +872,12 @@ async function checkGenericSource(source, enriched, config, state) {
   if (!checker)
     return;
   const result = await runSourceChecker(checker, enriched, config);
-  if (result.skipped)
+  if (result.skipReason) {
+    state.skipped.push({ source, reason: result.skipReason });
     return;
+  }
   state.sourcesChecked++;
+  state.checkedSources.push(source);
   if (result.error) {
     state.errors.push({ source, error: result.error });
   } else if (result.locations) {
@@ -873,6 +888,7 @@ async function lazyPmcCheck(enriched, state, discoveredIds) {
   if (!state.unpaywallPmcid || enriched.pmcid)
     return;
   discoveredIds.pmcid = discoveredIds.pmcid ?? state.unpaywallPmcid;
+  state.checkedSources.push("pmc-lazy");
   try {
     const pmcResult = await checkPmc({ pmcid: state.unpaywallPmcid });
     if (pmcResult) {
@@ -884,7 +900,13 @@ async function lazyPmcCheck(enriched, state, discoveredIds) {
 }
 async function discoverOA(article, config) {
   const { enriched, discoveredIds } = await enrichArticleIds(article, config);
-  const state = { locations: [], errors: [], sourcesChecked: 0 };
+  const state = {
+    locations: [],
+    errors: [],
+    skipped: [],
+    checkedSources: [],
+    sourcesChecked: 0
+  };
   const sourceOrder = config.preferSources.length > 0 ? config.preferSources : DEFAULT_SOURCE_ORDER;
   for (const source of sourceOrder) {
     if (source === "unpaywall") {
@@ -897,16 +919,24 @@ async function discoverOA(article, config) {
   }
   await lazyPmcCheck(enriched, state, discoveredIds);
   const oaStatus = determineOAStatus(state.locations, state.errors, state.sourcesChecked);
-  return { oaStatus, locations: state.locations, errors: state.errors, discoveredIds };
+  return {
+    oaStatus,
+    locations: state.locations,
+    errors: state.errors,
+    skipped: state.skipped,
+    checkedSources: state.checkedSources,
+    discoveredIds
+  };
 }
 async function runSourceChecker(checker, article, config) {
   try {
     const result = await checker(article, config);
-    if (result === void 0)
-      return { skipped: true };
-    return { skipped: false, locations: result ?? [] };
+    if (result !== null && typeof result === "object" && "skipped" in result) {
+      return { skipReason: result.skipped };
+    }
+    return { locations: result ?? [] };
   } catch (err) {
-    return { skipped: false, error: String(err) };
+    return { error: String(err) };
   }
 }
 const NON_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404, 405, 410]);
@@ -10240,6 +10270,7 @@ async function fulltextDiscover(library, options) {
   if (doi) article.doi = doi;
   if (pmid) article.pmid = pmid;
   if (pmcid) article.pmcid = pmcid;
+  if (item.custom?.arxiv_id) article.arxivId = item.custom.arxiv_id;
   const config = {
     unpaywallEmail: fulltextConfig.sources.unpaywallEmail ?? "",
     coreApiKey: fulltextConfig.sources.coreApiKey ?? "",
@@ -10275,6 +10306,7 @@ function buildDiscoveryArticle(item) {
   if (item.DOI) article.doi = item.DOI;
   if (item.PMID) article.pmid = item.PMID;
   if (item.PMCID) article.pmcid = item.PMCID;
+  if (item.custom?.arxiv_id) article.arxivId = item.custom.arxiv_id;
   return article;
 }
 function buildDiscoveryConfig(fulltextConfig) {
@@ -10287,13 +10319,22 @@ function buildDiscoveryConfig(fulltextConfig) {
   if (fulltextConfig.sources.ncbiTool) config.ncbiTool = fulltextConfig.sources.ncbiTool;
   return config;
 }
-async function tryDownloadPdf(locations, tempDir, ctx) {
+async function tryDownloadPdf(locations, tempDir, ctx, attempts) {
   const pdfLocations = locations.filter((loc) => loc.urlType === "pdf");
   if (pdfLocations.length === 0) return { attached: false, source: "" };
   const pdfPath = join(tempDir, "fulltext.pdf");
   for (const pdfLocation of pdfLocations) {
     const pdfResult = await downloadPdf(pdfLocation.url, pdfPath);
-    if (!pdfResult.success) continue;
+    if (!pdfResult.success) {
+      attempts.push({
+        source: pdfLocation.source,
+        phase: "download",
+        url: pdfLocation.url,
+        fileType: "pdf",
+        error: pdfResult.error ?? "Download failed"
+      });
+      continue;
+    }
     const attachResult = await fulltextAttach(ctx.library, {
       identifier: ctx.identifier,
       idType: ctx.idType,
@@ -10306,16 +10347,39 @@ async function tryDownloadPdf(locations, tempDir, ctx) {
     if (attachResult.success) {
       return { attached: true, source: pdfLocation.source };
     }
+    attempts.push({
+      source: pdfLocation.source,
+      phase: "attach",
+      url: pdfLocation.url,
+      fileType: "pdf",
+      error: "Failed to attach file"
+    });
   }
   return { attached: false, source: pdfLocations[0]?.source ?? "" };
 }
-async function tryDownloadPmcXmlAndConvert(pmcid, tempDir, ctx) {
+async function tryDownloadPmcXmlAndConvert(pmcid, tempDir, ctx, attempts) {
   const xmlPath = join(tempDir, "fulltext.xml");
   const xmlResult = await downloadPmcXml(pmcid, xmlPath);
-  if (!xmlResult.success) return false;
+  if (!xmlResult.success) {
+    attempts.push({
+      source: "pmc",
+      phase: "download",
+      fileType: "xml",
+      error: xmlResult.error ?? "Download failed"
+    });
+    return false;
+  }
   const mdPath = join(tempDir, "fulltext.md");
   const convertResult2 = await convertPmcXmlToMarkdown(xmlPath, mdPath);
-  if (!convertResult2.success) return false;
+  if (!convertResult2.success) {
+    attempts.push({
+      source: "pmc",
+      phase: "convert",
+      fileType: "xml",
+      error: convertResult2.error ?? "Conversion failed"
+    });
+    return false;
+  }
   const attachResult = await fulltextAttach(ctx.library, {
     identifier: ctx.identifier,
     idType: ctx.idType,
@@ -10325,19 +10389,43 @@ async function tryDownloadPmcXmlAndConvert(pmcid, tempDir, ctx) {
     move: true,
     fulltextDirectory: ctx.fulltextDirectory
   });
+  if (!attachResult.success) {
+    attempts.push({
+      source: "pmc",
+      phase: "attach",
+      fileType: "markdown",
+      error: "Failed to attach file"
+    });
+  }
   return attachResult.success;
 }
 function extractArxivId(url) {
   const match = url.match(/arxiv\.org\/(?:abs|html|pdf)\/(\d{4}\.\d{4,5}(?:v\d+)?)/);
   return match?.[1];
 }
-async function tryDownloadArxivHtmlAndConvert(arxivId, tempDir, ctx) {
+async function tryDownloadArxivHtmlAndConvert(arxivId, tempDir, ctx, attempts) {
   const htmlPath = join(tempDir, "fulltext.html");
   const htmlResult = await downloadArxivHtml(arxivId, htmlPath);
-  if (!htmlResult.success) return false;
+  if (!htmlResult.success) {
+    attempts.push({
+      source: "arxiv",
+      phase: "download",
+      fileType: "html",
+      error: htmlResult.error ?? "Download failed"
+    });
+    return false;
+  }
   const mdPath = join(tempDir, "fulltext.md");
   const convertResult2 = await convertArxivHtmlToMarkdown(htmlPath, mdPath);
-  if (!convertResult2.success) return false;
+  if (!convertResult2.success) {
+    attempts.push({
+      source: "arxiv",
+      phase: "convert",
+      fileType: "html",
+      error: convertResult2.error ?? "Conversion failed"
+    });
+    return false;
+  }
   const attachResult = await fulltextAttach(ctx.library, {
     identifier: ctx.identifier,
     idType: ctx.idType,
@@ -10347,12 +10435,36 @@ async function tryDownloadArxivHtmlAndConvert(arxivId, tempDir, ctx) {
     move: true,
     fulltextDirectory: ctx.fulltextDirectory
   });
+  if (!attachResult.success) {
+    attempts.push({
+      source: "arxiv",
+      phase: "attach",
+      fileType: "markdown",
+      error: "Failed to attach file"
+    });
+  }
   return attachResult.success;
 }
 async function checkExistingFulltext(library, identifier, idType, fulltextDirectory) {
   const existing = await fulltextGet(library, { identifier, idType, fulltextDirectory });
   return existing.success && existing.paths !== void 0;
 }
+function buildHintUrls(item) {
+  const urls = [];
+  if (item.DOI) urls.push(`https://doi.org/${item.DOI}`);
+  if (item.PMID) urls.push(`https://pubmed.ncbi.nlm.nih.gov/${item.PMID}/`);
+  return urls;
+}
+function formatHint(prefix, urls) {
+  if (urls.length === 0) return prefix;
+  if (urls.length === 1) return `${prefix}: ${urls[0]}`;
+  return `${prefix}:
+${urls.map((u) => `  ${u}`).join("\n")}`;
+}
+function buildNoSourcesHint(item) {
+  const urls = buildHintUrls(item);
+  return urls.length > 0 ? formatHint("open to download manually", urls) : void 0;
+}
 async function fulltextFetch(library, options) {
   const { identifier, idType = "id", fulltextConfig, fulltextDirectory, source, force } = options;
   const item = await library.find(identifier, { idType });
@@ -10375,12 +10487,22 @@ async function fulltextFetch(library, options) {
     buildDiscoveryArticle(item),
     buildDiscoveryConfig(fulltextConfig)
   );
+  const discoveryErrors = discovery.errors.length > 0 ? discovery.errors : void 0;
+  const skipped = discovery.skipped.length > 0 ? discovery.skipped : void 0;
+  const checkedSources = discovery.checkedSources.length > 0 ? discovery.checkedSources : void 0;
   let locations = discovery.locations;
   if (source) {
     locations = locations.filter((loc) => loc.source === source);
   }
   if (locations.length === 0) {
-    return { success: false, error: `No OA sources found for ${identifier}` };
+    return {
+      success: false,
+      error: `No OA sources found for ${identifier}`,
+      discoveryErrors,
+      checkedSources,
+      skipped,
+      hint: buildNoSourcesHint(item)
+    };
   }
   const effectivePmcid = item.PMCID ?? discovery.discoveredIds?.pmcid ?? extractPmcidFromLocations(locations);
   const tempDir = await mkdtemp(join(tmpdir(), "ref-fulltext-"));
@@ -10392,49 +10514,61 @@ async function fulltextFetch(library, options) {
     force: force ?? false
   };
   try {
-    return await downloadAndAttach(locations, effectivePmcid, tempDir, ctx, item.id, identifier);
+    const result = await downloadAndAttach(
+      locations,
+      effectivePmcid,
+      tempDir,
+      ctx,
+      item.id,
+      identifier
+    );
+    return { ...result, discoveryErrors, checkedSources, skipped };
   } finally {
     await rm(tempDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
-async function tryArxivHtmlFromLocations(locations, tempDir, ctx) {
+async function tryArxivHtmlFromLocations(locations, tempDir, ctx, attempts) {
   const arxivHtmlLocation = locations.find(
     (loc) => loc.source === "arxiv" && loc.urlType === "html"
   );
   if (!arxivHtmlLocation) return { attached: false, source: "" };
   const arxivId = extractArxivId(arxivHtmlLocation.url);
   if (!arxivId) return { attached: false, source: "arxiv" };
-  const mdAttached = await tryDownloadArxivHtmlAndConvert(arxivId, tempDir, ctx);
+  const mdAttached = await tryDownloadArxivHtmlAndConvert(arxivId, tempDir, ctx, attempts);
   return { attached: mdAttached, source: "arxiv" };
 }
-function buildDownloadError(locations, identifier) {
+function buildDownloadError(locations, identifier, attempts) {
+  const attemptUrls = attempts.filter((a) => a.url).map((a) => a.url);
+  const hint = attemptUrls.length > 0 ? formatHint("open to download manually (may require institutional access)", attemptUrls) : void 0;
   const pdfLocation = locations.find((loc) => loc.urlType === "pdf");
   if (pdfLocation) {
     return {
       success: false,
-      error: `Failed to download from ${pdfLocation.source}: download failed`
+      error: `Failed to download from ${pdfLocation.source}: download failed`,
+      hint
     };
   }
-  return { success: false, error: `Failed to download fulltext for ${identifier}` };
+  return { success: false, error: `Failed to download fulltext for ${identifier}`, hint };
 }
 async function downloadAndAttach(locations, pmcid, tempDir, ctx, referenceId, identifier) {
   const attachedFiles = [];
   let usedSource = "";
-  const pdfResult = await tryDownloadPdf(locations, tempDir, ctx);
+  const attempts = [];
+  const pdfResult = await tryDownloadPdf(locations, tempDir, ctx, attempts);
   if (pdfResult.attached) {
     attachedFiles.push("pdf");
     usedSource = pdfResult.source;
   }
   if (pmcid) {
-    const mdAttached = await tryDownloadPmcXmlAndConvert(pmcid, tempDir, ctx);
+    const mdAttached = await tryDownloadPmcXmlAndConvert(pmcid, tempDir, ctx, attempts);
     if (mdAttached) {
       attachedFiles.push("markdown");
       if (!usedSource) usedSource = "pmc";
     }
   }
   if (!attachedFiles.includes("markdown")) {
-    const arxivResult = await tryArxivHtmlFromLocations(locations, tempDir, ctx);
+    const arxivResult = await tryArxivHtmlFromLocations(locations, tempDir, ctx, attempts);
     if (arxivResult.attached) {
       attachedFiles.push("markdown");
       if (!usedSource) usedSource = arxivResult.source;
@@ -10443,7 +10577,10 @@ async function downloadAndAttach(locations, pmcid, tempDir, ctx, referenceId, id
   if (attachedFiles.length > 0) {
     return { success: true, referenceId, source: usedSource, attachedFiles };
   }
-  return buildDownloadError(locations, identifier);
+  return {
+    ...buildDownloadError(locations, identifier, attempts),
+    attempts: attempts.length > 0 ? attempts : void 0
+  };
 }
 const fetch$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -10511,6 +10648,7 @@ function formatFirstAuthor(item) {
   if (!firstAuthor) {
     return "Unknown";
   }
+  if (firstAuthor.literal) return firstAuthor.literal;
   const family = firstAuthor.family || "Unknown";
   const givenInitial = firstAuthor.given ? firstAuthor.given[0] : "";
   if (givenInitial) {
@@ -10600,6 +10738,7 @@ function getFirstAuthorFamilyName(item) {
   if (!firstAuthor) {
     return "Unknown";
   }
+  if (firstAuthor.literal) return firstAuthor.literal;
   return firstAuthor.family || "Unknown";
 }
 function formatInTextEntry(item) {
@@ -10950,6 +11089,13 @@ function getIsbnFromCache(isbn) {
 function cacheIsbnResult(isbn, item, config) {
   storeInCache(isbnCache, isbn, item);
 }
+const arxivCache = /* @__PURE__ */ new Map();
+function getArxivFromCache(arxivId) {
+  return getFromCache(arxivCache, arxivId);
+}
+function cacheArxivResult(arxivId, item, config) {
+  storeInCache(arxivCache, arxivId, item);
+}
 const DOI_URL_PREFIXES$1 = [
   "https://doi.org/",
   "http://doi.org/",
@@ -10990,6 +11136,28 @@ function normalizeIsbn(isbn) {
   normalized = normalized.toUpperCase();
   return normalized;
 }
+const ARXIV_URL_PREFIXES = [
+  "https://arxiv.org/abs/",
+  "http://arxiv.org/abs/",
+  "https://arxiv.org/pdf/",
+  "http://arxiv.org/pdf/",
+  "https://arxiv.org/html/",
+  "http://arxiv.org/html/"
+];
+function normalizeArxiv(arxiv) {
+  const trimmed = arxiv.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lowerInput = trimmed.toLowerCase();
+  for (const prefix of ARXIV_URL_PREFIXES) {
+    if (lowerInput.startsWith(prefix.toLowerCase())) {
+      return trimmed.slice(prefix.length);
+    }
+  }
+  const withoutPrefix = trimmed.replace(/^arxiv:\s*/i, "");
+  return withoutPrefix;
+}
 const EXTENSION_MAP = {
   ".json": "json",
   ".bib": "bibtex",
@@ -11050,6 +11218,9 @@ function detectSingleIdentifier(input) {
   if (isDoi(input)) {
     return "doi";
   }
+  if (isArxiv(input)) {
+    return "arxiv";
+  }
   if (isIsbn(input)) {
     return "isbn";
   }
@@ -11112,6 +11283,17 @@ function isIsbn(input) {
   }
   return true;
 }
+const ARXIV_ID_PATTERN = /^\d{4}\.\d{4,5}(v\d+)?$/;
+function isArxiv(input) {
+  if (!input || input.length === 0) {
+    return false;
+  }
+  const normalized = normalizeArxiv(input);
+  if (!normalized) {
+    return false;
+  }
+  return ARXIV_ID_PATTERN.test(normalized);
+}
 const RATE_LIMITS = {
   pubmed: {
     withoutApiKey: 3,
@@ -11121,8 +11303,10 @@ const RATE_LIMITS = {
   },
   crossref: 50,
   // 50 req/sec
-  isbn: 10
+  isbn: 10,
   // 10 req/sec (conservative for Google Books API daily limit)
+  arxiv: 1
+  // 1 req/sec (arXiv API is strict about rate limiting)
 };
 class RateLimiterImpl {
   requestsPerSecond;
@@ -11175,6 +11359,8 @@ function getRequestsPerSecond(api, config) {
       return RATE_LIMITS.crossref;
     case "isbn":
       return RATE_LIMITS.isbn;
+    case "arxiv":
+      return RATE_LIMITS.arxiv;
   }
 }
 const PMC_API_BASE = "https://pmc.ncbi.nlm.nih.gov/api/ctxp/v1/pubmed/";
@@ -11354,8 +11540,108 @@ async function fetchIsbn(isbn) {
     };
   }
 }
+const ARXIV_API_BASE = "https://export.arxiv.org/api/query";
+function extractXmlText(xml, tagName) {
+  const regex = new RegExp(`<${tagName}[^>]*>([\\s\\S]*?)</${tagName}>`);
+  const match = regex.exec(xml);
+  return match?.[1]?.trim() ?? "";
+}
+function extractAuthors(entryXml) {
+  const authors = [];
+  const matches = entryXml.matchAll(/<author>[\s\S]*?<name>([^<]+)<\/name>[\s\S]*?<\/author>/g);
+  for (const match of matches) {
+    const name = match[1]?.trim();
+    if (name) {
+      authors.push({ literal: name });
+    }
+  }
+  return authors;
+}
+function extractJournalDoi(entryXml) {
+  const match = /<arxiv:doi[^>]*>([^<]+)<\/arxiv:doi>/.exec(entryXml);
+  return match?.[1]?.trim();
+}
+function parseIssuedDate(dateStr) {
+  if (!dateStr) return void 0;
+  const date = new Date(dateStr);
+  if (Number.isNaN(date.getTime())) return void 0;
+  return {
+    "date-parts": [[date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()]]
+  };
+}
+async function fetchArxiv(arxivId) {
+  if (!ARXIV_ID_PATTERN.test(arxivId)) {
+    return {
+      success: false,
+      error: `Invalid arXiv ID format: ${arxivId}`,
+      reason: "validation_error"
+    };
+  }
+  const rateLimiter = getRateLimiter("arxiv", {});
+  await rateLimiter.acquire();
+  try {
+    const url = `${ARXIV_API_BASE}?id_list=${encodeURIComponent(arxivId)}`;
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `arXiv API returned status ${response.status}`,
+        reason: "fetch_error"
+      };
+    }
+    const xml = await response.text();
+    const entryMatch = /<entry>([\s\S]*?)<\/entry>/.exec(xml);
+    if (!entryMatch) {
+      return {
+        success: false,
+        error: `No results found for arXiv ID ${arxivId}`,
+        reason: "not_found"
+      };
+    }
+    const entryXml = entryMatch[1] ?? "";
+    const title = extractXmlText(entryXml, "title");
+    const summary = extractXmlText(entryXml, "summary");
+    const published = extractXmlText(entryXml, "published");
+    const authors = extractAuthors(entryXml);
+    const journalDoi = extractJournalDoi(entryXml);
+    const baseId = arxivId.replace(/v\d+$/, "");
+    const doi = journalDoi ?? `10.48550/arXiv.${baseId}`;
+    const item = {
+      id: "",
+      type: "article",
+      title,
+      author: authors,
+      abstract: summary || void 0,
+      issued: parseIssuedDate(published),
+      DOI: doi,
+      URL: `https://arxiv.org/abs/${arxivId}`,
+      custom: {
+        arxiv_id: arxivId
+      }
+    };
+    const parseResult = CslItemSchema.safeParse(item);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        error: `Invalid CSL-JSON data for arXiv ${arxivId}: ${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 fetcher = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  fetchArxiv,
   fetchDoi,
   fetchIsbn,
   fetchPmids
@@ -11550,19 +11836,22 @@ function classifyIdentifiers(identifiers) {
   const pmids = [];
   const dois = [];
   const isbns = [];
+  const arxivs = [];
   const unknowns = [];
   for (const id of identifiers) {
-    if (isPmid(id)) {
-      pmids.push(normalizePmid(id));
-    } else if (isDoi(id)) {
+    if (isDoi(id)) {
       dois.push(normalizeDoi(id));
+    } else if (isArxiv(id)) {
+      arxivs.push(normalizeArxiv(id));
     } else if (isIsbn(id)) {
       isbns.push(normalizeIsbn(id));
+    } else if (isPmid(id)) {
+      pmids.push(normalizePmid(id));
     } else {
       unknowns.push(id);
     }
   }
-  return { pmids, dois, isbns, unknowns };
+  return { pmids, dois, isbns, arxivs, unknowns };
 }
 function buildUnknownResults(unknowns) {
   return unknowns.map((unknown) => ({
@@ -11655,6 +11944,29 @@ async function fetchIsbnsWithCache(isbns) {
   }
   return results;
 }
+async function fetchArxivsWithCache(arxivIds) {
+  const results = [];
+  for (const arxivId of arxivIds) {
+    const cached = getArxivFromCache(arxivId);
+    if (cached) {
+      results.push({ success: true, item: clearItemId(cached), source: arxivId });
+      continue;
+    }
+    const fetchResult = await fetchArxiv(arxivId);
+    if (fetchResult.success) {
+      cacheArxivResult(arxivId, fetchResult.item);
+      results.push({ success: true, item: clearItemId(fetchResult.item), source: arxivId });
+    } else {
+      results.push({
+        success: false,
+        error: fetchResult.error,
+        source: arxivId,
+        reason: fetchResult.reason
+      });
+    }
+  }
+  return results;
+}
 function parseJsonContent(content) {
   try {
     const parsed = JSON.parse(content);
@@ -11811,7 +12123,7 @@ async function importFromIdentifiers(identifiers, options) {
   if (identifiers.length === 0) {
     return { results: [] };
   }
-  const { pmids, dois, isbns, unknowns } = classifyIdentifiers(identifiers);
+  const { pmids, dois, isbns, arxivs, unknowns } = classifyIdentifiers(identifiers);
   const results = [];
   results.push(...buildUnknownResults(unknowns));
   const pmidResults = await fetchPmidsWithCache(pmids, options.pubmedConfig ?? {});
@@ -11820,6 +12132,8 @@ async function importFromIdentifiers(identifiers, options) {
   results.push(...doiResults);
   const isbnResults = await fetchIsbnsWithCache(isbns);
   results.push(...isbnResults);
+  const arxivResults = await fetchArxivsWithCache(arxivs);
+  results.push(...arxivResults);
   return { results };
 }
 function looksLikeFilePath(input) {
@@ -11861,13 +12175,14 @@ async function processIdentifiers(inputs, options) {
     const isValidPmid = isPmid(input);
     const isValidDoi = isDoi(input);
     const isValidIsbn = isIsbn(input);
-    if (isValidPmid || isValidDoi || isValidIsbn) {
+    const isValidArxiv = isArxiv(input);
+    if (isValidPmid || isValidDoi || isValidIsbn || isValidArxiv) {
       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}`,
+        error: `Cannot interpret '${input}' as identifier (not a valid PMID, DOI, ISBN, or arXiv ID).${hint}`,
         source: input,
         reason: "validation_error"
       });
@@ -11911,7 +12226,7 @@ async function processStdinContent(content, options) {
       source: r.source === "content" ? "stdin" : r.source
     }));
   }
-  if (format === "pmid" || format === "doi" || format === "isbn") {
+  if (format === "pmid" || format === "doi" || format === "isbn" || format === "arxiv") {
     const identifiers2 = content.split(/\s+/).filter((s) => s.length > 0);
     return processIdentifiers(identifiers2, options);
   }
@@ -12084,7 +12399,7 @@ function createAddRoute(library, config) {
 }
 const CHECK_CONCURRENCY = 5;
 async function checkReferences(library, options) {
-  const { checkReference } = await import("./checker-B-SL7krG.js");
+  const { checkReference } = await import("./checker-CP8vSC-S.js");
   const save = options.save !== false;
   const skipDays = options.skipDays ?? 7;
   const items = await resolveItems(library, options);
@@ -12114,7 +12429,7 @@ function fillSkippedResults(tasks, results) {
         uuid: task.item.custom?.uuid ?? "",
         status: "skipped",
         findings: [],
-        checkedAt: task.item.custom?.check?.checked_at,
+        checkedAt: task.item.custom?.check?.checked_at ?? "",
         checkedSources: []
       };
     }
@@ -12176,11 +12491,11 @@ async function resolveItems(library, options) {
 }
 function shouldSkipRecentCheck(item, skipDays) {
   if (skipDays <= 0) return false;
-  const check2 = item.custom?.check;
-  if (!check2?.checked_at) return false;
-  const checkedAt = new Date(check2.checked_at);
+  const checkedAt = item.custom?.check?.checked_at;
+  if (!checkedAt) return false;
+  const checkedAtDate = new Date(checkedAt);
   const now = /* @__PURE__ */ new Date();
-  const daysSince = (now.getTime() - checkedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  const daysSince = (now.getTime() - checkedAtDate.getTime()) / (1e3 * 60 * 60 * 24);
   return daysSince < skipDays;
 }
 async function saveCheckResult(library, item, result) {
@@ -12193,9 +12508,8 @@ async function saveCheckResult(library, item, result) {
       ...f.details ? { details: snakeCaseKeys(f.details) } : {}
     }))
   };
-  const existingCustom = item.custom ?? {};
   await library.update(item.id, {
-    custom: { ...existingCustom, check: checkData }
+    custom: { ...item.custom, check: checkData }
   });
 }
 function snakeCaseKeys(obj) {
@@ -12764,4 +13078,4 @@ export {
   fetcher as y,
   add as z
 };
-//# sourceMappingURL=index-DUpYvm-W.js.map
+//# sourceMappingURL=index-T-edKSzd.js.map