@ncukondo/reference-manager 0.32.0 → 0.33.0

package/dist/chunks/{index-B4-i4PrU.js → index-a52FHX03.js}

@@ -1,22 +1,26 @@
 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-CWHg1yol.js";
 import * as fs from "node:fs";
-import { mkdtempSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { mkdtempSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import fs__default, { stat, rename, copyFile, unlink, rm, readFile, mkdir, writeFile, access, mkdtemp, rmdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import path__default, { extname, join, dirname, basename } from "node:path";
 import { Cite, plugins, util } 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 { createRequire } from "node:module";
+import { chromium } from "playwright-core";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
 import { z } from "zod";
-import * as path from "node:path";
-import path__default, { extname, join, dirname, basename } from "node:path";
 import "@citation-js/plugin-csl";
-import fs__default, { stat, rename, copyFile, unlink, rm, readFile, mkdir, writeFile, access, mkdtemp, rmdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { exec, execFile } from "node:child_process";
 import "node:crypto";
 const name = "@ncukondo/reference-manager";
-const version = "0.32.0";
+const version = "0.33.0";
 const description = "A local reference management tool using CSL-JSON as the single source of truth";
 const publishConfig = { "access": "public" };
 const type$1 = "module";
@@ -27,8 +31,8 @@ const types = "./dist/index.d.ts";
 const exports$1 = { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } };
 const files = ["dist", "bin"];
 const scripts = { "dev": "vite", "build": "vite build && tsc --emitDeclarationOnly", "preview": "vite preview", "test": "vitest --project unit", "test:unit": "vitest --project unit", "test:e2e": "vitest run --project e2e", "test:remote": "vitest --project remote", "test:all": "vitest --project unit && vitest --project e2e && vitest --project remote", "test:watch": "vitest --watch --project unit", "test:coverage": "vitest run --coverage --project unit", "lint": "biome check .", "lint:fix": "biome check --write .", "format": "biome format --write .", "typecheck": "tsc --noEmit", "check:paths": "! grep -rn --include='*.ts' --exclude='*.test.ts' --exclude='*.d.ts' --exclude='path.ts' '\\.replace(/\\\\\\\\' src/ 2>/dev/null", "check:no-process-exit": "! grep -rn --include='*.ts' --exclude='*.test.ts' 'process\\.exit(' src/cli/ 2>/dev/null | grep -v 'helpers.ts' | grep -v '// '", "prepublishOnly": "npm run build", "prepare": "husky || true" };
-const dependencies = { "@citation-js/core": "^0.7.16", "@citation-js/plugin-bibtex": "^0.7.21", "@citation-js/plugin-csl": "^0.7.16", "@citation-js/plugin-doi": "^0.7.21", "@citation-js/plugin-isbn": "^0.4.0", "@citation-js/plugin-ris": "^0.7.21", "@iarna/toml": "^2.2.5", "@modelcontextprotocol/sdk": "^1.25.1", "@ncukondo/academic-fulltext": "^0.2.6", "chokidar": "^5.0.0", "commander": "^12.1.0", "env-paths": "^3.0.0", "hono": "^4.11.1", "ink": "^6.6.0", "ink-ui": "^0.4.0", "js-yaml": "^4.1.1", "react": "^19.2.3", "tabtab": "^3.0.2", "write-file-atomic": "^7.0.0", "yaml": "^2.8.2", "zod": "^4.1.13" };
-const devDependencies = { "@biomejs/biome": "^1.9.0", "@hono/node-server": "^1.19.7", "@types/chokidar": "^1.7.5", "@types/js-yaml": "^4.0.9", "@types/node": "^22.19.2", "@types/react": "^19.2.9", "@types/tabtab": "^3.0.4", "@types/write-file-atomic": "^4.0.3", "@vitest/coverage-v8": "^2.1.9", "husky": "^9.1.7", "lint-staged": "^16.2.7", "react-devtools-core": "^6.1.5", "typescript": "^5.6.0", "vite": "^6.0.0", "vite-node": "^2.1.0", "vitest": "^2.1.0" };
+const dependencies = { "@citation-js/core": "^0.7.16", "@citation-js/plugin-bibtex": "^0.7.21", "@citation-js/plugin-csl": "^0.7.16", "@citation-js/plugin-doi": "^0.7.21", "@citation-js/plugin-isbn": "^0.4.0", "@citation-js/plugin-ris": "^0.7.21", "@iarna/toml": "^2.2.5", "@modelcontextprotocol/sdk": "^1.25.1", "@mozilla/readability": "^0.6.0", "@ncukondo/academic-fulltext": "^0.2.6", "chokidar": "^5.0.0", "commander": "^12.1.0", "env-paths": "^3.0.0", "hono": "^4.11.1", "ink": "^6.6.0", "ink-ui": "^0.4.0", "js-yaml": "^4.1.1", "playwright-core": "^1.58.2", "react": "^19.2.3", "tabtab": "^3.0.2", "turndown": "^7.2.2", "turndown-plugin-gfm": "^1.0.2", "write-file-atomic": "^7.0.0", "yaml": "^2.8.2", "zod": "^4.1.13" };
+const devDependencies = { "@biomejs/biome": "^1.9.0", "@hono/node-server": "^1.19.7", "@types/chokidar": "^1.7.5", "@types/js-yaml": "^4.0.9", "@types/jsdom": "^28.0.1", "@types/node": "^22.19.2", "@types/react": "^19.2.9", "@types/tabtab": "^3.0.4", "@types/turndown": "^5.0.6", "@types/write-file-atomic": "^4.0.3", "@vitest/coverage-v8": "^2.1.9", "husky": "^9.1.7", "jsdom": "^29.0.1", "lint-staged": "^16.2.7", "react-devtools-core": "^6.1.5", "typescript": "^5.6.0", "vite": "^6.0.0", "vite-node": "^2.1.0", "vitest": "^2.1.0" };
 const keywords = ["reference-manager", "csl-json", "bibliography", "pandoc", "citation"];
 const author = "";
 const license = "MIT";
@@ -92,7 +96,7 @@ function parseFilename(filename) {
     ext: extWithoutDot
   };
 }
-const RESERVED_ROLES = ["fulltext", "supplement", "notes", "draft"];
+const RESERVED_ROLES = ["fulltext", "supplement", "notes", "draft", "archive"];
 function isReservedRole(role) {
   return RESERVED_ROLES.includes(role);
 }
@@ -7394,7 +7398,7 @@ function extractRefText(item) {
   }
   return text2;
 }
-function extractDoi(item) {
+function extractDoi$1(item) {
   for (const link of qa(item, "a")) {
     const href = link.getAttribute("href") ?? "";
     const doiMatch = href.match(/doi\.org\/(.+)/);
@@ -7408,7 +7412,7 @@ function parseReferences(root) {
   for (const item of qa(root, ".ltx_bibitem")) {
     const id = item.getAttribute("id") ?? `ref${refs.length + 1}`;
     const text2 = extractRefText(item);
-    const doi = extractDoi(item);
+    const doi = extractDoi$1(item);
     const ref = { id, text: text2 };
     if (doi)
       ref.doi = doi;
@@ -11644,11 +11648,54 @@ function detectSingleIdentifier(input) {
   if (isIsbn(input)) {
     return "isbn";
   }
+  if (extractPubmedId(input) !== null) {
+    return "pmid";
+  }
   if (isPmid(input)) {
     return "pmid";
   }
+  if (isUrl(input)) {
+    return "url";
+  }
   return "unknown";
 }
+const PUBMED_URL_PATTERNS = [
+  // https://pubmed.ncbi.nlm.nih.gov/{PMID}/
+  {
+    pattern: /^https?:\/\/pubmed\.ncbi\.nlm\.nih\.gov\/(\d+)\/?$/,
+    extract: (m) => m[1]
+  },
+  // https://www.ncbi.nlm.nih.gov/pubmed/{PMID}
+  {
+    pattern: /^https?:\/\/(?:www\.)?ncbi\.nlm\.nih\.gov\/pubmed\/(\d+)\/?$/,
+    extract: (m) => m[1]
+  },
+  // https://pmc.ncbi.nlm.nih.gov/articles/PMC{ID}/
+  {
+    pattern: /^https?:\/\/(?:www\.)?pmc\.ncbi\.nlm\.nih\.gov\/articles\/PMC(\d+)\/?$/,
+    extract: (m) => `PMC${m[1]}`
+  }
+];
+function extractPubmedId(input) {
+  for (const { pattern, extract } of PUBMED_URL_PATTERNS) {
+    const match = pattern.exec(input);
+    if (match) {
+      return extract(match);
+    }
+  }
+  return null;
+}
+function isUrl(input) {
+  if (!input) return false;
+  const lower = input.toLowerCase();
+  if (!lower.startsWith("http://") && !lower.startsWith("https://")) {
+    return false;
+  }
+  if (isDoi(input)) return false;
+  if (isArxiv(input)) return false;
+  if (extractPubmedId(input) !== null) return false;
+  return true;
+}
 function isDoi(input) {
   for (const prefix of DOI_URL_PREFIXES) {
     if (input.toLowerCase().startsWith(prefix.toLowerCase())) {
@@ -12306,6 +12353,439 @@ function isEmptyFormat(content, format) {
   }
   return false;
 }
+class BrowserNotFoundError extends Error {
+  constructor(cause) {
+    const message = [
+      "Browser not found. URL import requires Chrome or Chromium.",
+      "",
+      "  Install one of the following:",
+      "",
+      "    Google Chrome:  https://www.google.com/chrome/",
+      "    Chromium:       sudo apt install chromium-browser   (Ubuntu/Debian)",
+      "                    brew install --cask chromium         (macOS)",
+      "",
+      "  Or specify the path manually:",
+      "",
+      "    [url]",
+      '    browser_path = "/path/to/chrome"'
+    ].join("\n");
+    super(message, { cause });
+    this.name = "BrowserNotFoundError";
+  }
+}
+async function launchBrowser(config) {
+  try {
+    const launchOptions = {
+      headless: true
+    };
+    if (config.browserPath) {
+      launchOptions.executablePath = config.browserPath;
+    } else {
+      launchOptions.channel = "chrome";
+    }
+    return await chromium.launch(launchOptions);
+  } catch (error) {
+    throw new BrowserNotFoundError(error instanceof Error ? error : void 0);
+  }
+}
+async function captureMhtml(page) {
+  const cdp = await page.context().newCDPSession(page);
+  try {
+    const { data } = await cdp.send("Page.captureSnapshot", { format: "mhtml" });
+    return data;
+  } finally {
+    await cdp.detach();
+  }
+}
+async function captureHtml(page) {
+  return page.evaluate("document.documentElement.outerHTML");
+}
+async function createArchive(page, format) {
+  if (format === "mhtml") {
+    const data2 = await captureMhtml(page);
+    return { data: data2, extension: "mhtml" };
+  }
+  const data = await captureHtml(page);
+  return { data, extension: "html" };
+}
+async function extractContent(page) {
+  return page.evaluate(`
+    (() => {
+      let content = null;
+      try {
+        if (typeof Readability !== "undefined") {
+          const reader = new Readability(document.cloneNode(true));
+          const article = reader.parse();
+          content = article ? article.content : null;
+        }
+      } catch (e) {}
+      return {
+        content: content,
+        fullHtml: document.documentElement.outerHTML,
+      };
+    })()
+  `);
+}
+function htmlToMarkdown(html2) {
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced"
+  });
+  turndown.use(gfm);
+  return turndown.turndown(html2);
+}
+async function generateFulltext(page) {
+  const extracted = await extractContent(page);
+  const html2 = extracted.content ?? extracted.fullHtml;
+  if (!html2) {
+    return "";
+  }
+  return htmlToMarkdown(html2);
+}
+const SCHEMA_TYPE_TO_CSL = {
+  Legislation: "legislation",
+  LegislationObject: "legislation",
+  Report: "report",
+  Article: "article",
+  ScholarlyArticle: "article-journal",
+  NewsArticle: "article-newspaper",
+  WebPage: "webpage"
+};
+function parseDate(raw) {
+  const cleaned = raw.replace(/\//g, "-");
+  const parts = cleaned.split("-").map(Number);
+  if (parts.length >= 1 && !Number.isNaN(parts[0])) {
+    return { "date-parts": [parts.filter((p) => !Number.isNaN(p))] };
+  }
+  return void 0;
+}
+function isEmptyAuthor(a) {
+  return !a.family && !a.given && !a.literal;
+}
+function parseName(name2) {
+  const trimmed = name2.trim();
+  if (!trimmed) return { literal: "" };
+  if (trimmed.includes(",")) {
+    const parts = trimmed.split(",");
+    const family = parts[0] ?? "";
+    const given = parts.slice(1).join(",").trim();
+    const result = { family: family.trim() };
+    if (given) result.given = given;
+    return result;
+  }
+  const spaceIdx = trimmed.lastIndexOf(" ");
+  if (spaceIdx > 0) {
+    return {
+      given: trimmed.slice(0, spaceIdx),
+      family: trimmed.slice(spaceIdx + 1)
+    };
+  }
+  return { literal: trimmed };
+}
+const PRIORITY_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "Article",
+  "ScholarlyArticle",
+  "NewsArticle",
+  "Report",
+  "Legislation",
+  "LegislationObject"
+]);
+function isObj(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+function findInGraph(graph) {
+  for (const item of graph) {
+    if (!isObj(item)) continue;
+    const t = item["@type"];
+    if (typeof t === "string" && PRIORITY_SCHEMA_TYPES.has(t)) return item;
+  }
+  for (const item of graph) {
+    if (isObj(item) && item.name) return item;
+  }
+  return void 0;
+}
+function findBestJsonLdItem(jsonLdArray) {
+  for (const entry of jsonLdArray) {
+    if (!isObj(entry)) continue;
+    if (Array.isArray(entry["@graph"])) {
+      const found = findInGraph(entry["@graph"]);
+      if (found) return found;
+    }
+    if (entry["@type"]) return entry;
+  }
+  return void 0;
+}
+function extractJsonLdAuthor(rawAuthor) {
+  const authors = Array.isArray(rawAuthor) ? rawAuthor : [rawAuthor];
+  return authors.filter(isObj).map((a) => {
+    const name2 = typeof a.name === "string" ? a.name : "";
+    if (a["@type"] === "Organization") return { literal: name2 };
+    return parseName(name2);
+  });
+}
+function extractJsonLdPublisher(pub) {
+  if (typeof pub === "string") return pub;
+  if (isObj(pub) && typeof pub.name === "string") return pub.name;
+  return void 0;
+}
+function extractJsonLdDate(item) {
+  if (typeof item.datePublished === "string") return item.datePublished;
+  if (typeof item.legislationDate === "string") return item.legislationDate;
+  return void 0;
+}
+function extractDoi(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.replace(/^https?:\/\/(dx\.)?doi\.org\//, "");
+  if (normalized.startsWith("10.")) return normalized;
+  return void 0;
+}
+function setDateField(fields, dateStr) {
+  if (!dateStr) return;
+  const parsed = parseDate(dateStr);
+  if (parsed) fields.issued = parsed;
+}
+function extractFromJsonLd(jsonLdArray) {
+  const item = findBestJsonLdItem(jsonLdArray);
+  if (!item) return {};
+  const fields = {};
+  if (typeof item.name === "string" && item.name) fields.title = item.name;
+  if (typeof item["@type"] === "string") {
+    const mapped = SCHEMA_TYPE_TO_CSL[item["@type"]];
+    if (mapped) fields.type = mapped;
+  }
+  if (item.author) {
+    const authors = extractJsonLdAuthor(item.author);
+    if (authors.length) fields.author = authors;
+  }
+  setDateField(fields, extractJsonLdDate(item));
+  const doi = extractDoi(item.identifier);
+  if (doi) fields.DOI = doi;
+  const pub = extractJsonLdPublisher(item.publisher);
+  if (pub) fields.publisher = pub;
+  if (typeof item.description === "string" && item.description) fields.abstract = item.description;
+  return fields;
+}
+function extractFromCitation(citation) {
+  const fields = {};
+  if (typeof citation.citation_title === "string" && citation.citation_title) {
+    fields.title = citation.citation_title;
+  }
+  const rawAuthors = citation.citation_author;
+  if (rawAuthors) {
+    const authorList = Array.isArray(rawAuthors) ? rawAuthors : [rawAuthors];
+    const parsed = authorList.map((a) => parseName(a)).filter((a) => !isEmptyAuthor(a));
+    if (parsed.length) fields.author = parsed;
+  }
+  const dateStr = (typeof citation.citation_date === "string" ? citation.citation_date : void 0) || (typeof citation.citation_publication_date === "string" ? citation.citation_publication_date : void 0);
+  setDateField(fields, dateStr);
+  if (typeof citation.citation_doi === "string" && citation.citation_doi) {
+    fields.DOI = citation.citation_doi;
+  }
+  if (typeof citation.citation_journal_title === "string" && citation.citation_journal_title) {
+    fields["container-title"] = citation.citation_journal_title;
+  }
+  return fields;
+}
+function dcString(val) {
+  if (typeof val === "string") return val;
+  if (Array.isArray(val) && val.length > 0) return val[0];
+  return void 0;
+}
+function extractFromDublinCore(dc) {
+  const fields = {};
+  const title = dcString(dc["DC.title"]);
+  if (title) fields.title = title;
+  const rawCreator = dc["DC.creator"];
+  if (rawCreator) {
+    const creators = Array.isArray(rawCreator) ? rawCreator : [rawCreator];
+    const parsed = creators.map((c) => parseName(c)).filter((a) => !isEmptyAuthor(a));
+    if (parsed.length) fields.author = parsed;
+  }
+  setDateField(fields, dcString(dc["DC.date"]));
+  const publisher = dcString(dc["DC.publisher"]);
+  if (publisher) fields.publisher = publisher;
+  const description2 = dcString(dc["DC.description"]);
+  if (description2) fields.abstract = description2;
+  const doi = extractDoi(dcString(dc["DC.identifier"]));
+  if (doi) fields.DOI = doi;
+  return fields;
+}
+function extractFromOpenGraph(og) {
+  const fields = {};
+  if (og["og:title"]) fields.title = og["og:title"];
+  if (og["og:description"]) fields.abstract = og["og:description"];
+  return fields;
+}
+const SIMPLE_KEYS = ["title", "type", "DOI", "container-title", "publisher", "abstract"];
+function mergeFields(...sources) {
+  const merged = {};
+  for (const key of SIMPLE_KEYS) {
+    const source = sources.find((s) => s[key]);
+    if (source?.[key]) merged[key] = source[key];
+  }
+  const authorSource = sources.find((s) => s.author?.length);
+  if (authorSource?.author) merged.author = authorSource.author;
+  const issuedSource = sources.find((s) => s.issued);
+  if (issuedSource?.issued) merged.issued = issuedSource.issued;
+  return merged;
+}
+async function extractMetadata(page) {
+  const rawMeta = await page.evaluate(`
+    (() => {
+      const jsonLd = [...document.querySelectorAll('script[type="application/ld+json"]')]
+        .map(el => { try { return JSON.parse(el.textContent || ""); } catch { return null; } })
+        .filter(Boolean);
+
+      const citationMulti = {};
+      for (const el of document.querySelectorAll('meta[name^="citation_"]')) {
+        const name = el.getAttribute("name") || "";
+        const content = el.getAttribute("content") || "";
+        if (!citationMulti[name]) citationMulti[name] = [];
+        citationMulti[name].push(content);
+      }
+      const citation = {};
+      for (const [key, values] of Object.entries(citationMulti)) {
+        citation[key] = values.length === 1 ? values[0] : values;
+      }
+
+      const dcMulti = {};
+      for (const el of document.querySelectorAll('meta[name^="DC."]')) {
+        const name = el.getAttribute("name") || "";
+        const content = el.getAttribute("content") || "";
+        if (!dcMulti[name]) dcMulti[name] = [];
+        dcMulti[name].push(content);
+      }
+      const dc = {};
+      for (const [key, values] of Object.entries(dcMulti)) {
+        dc[key] = values.length === 1 ? values[0] : values;
+      }
+      const og = Object.fromEntries(
+        [...document.querySelectorAll('meta[property^="og:"]')]
+          .map(el => [el.getAttribute("property"), el.getAttribute("content") || ""])
+          .filter(([k]) => k));
+      return { jsonLd, citation, dc, og, title: document.title };
+    })()
+  `);
+  const pageUrl = page.url();
+  const jsonLdFields = extractFromJsonLd(rawMeta.jsonLd);
+  const citationFields = extractFromCitation(rawMeta.citation);
+  const dcFields = extractFromDublinCore(rawMeta.dc);
+  const ogFields = extractFromOpenGraph(rawMeta.og);
+  const htmlFields = {};
+  if (rawMeta.title) htmlFields.title = rawMeta.title;
+  const merged = mergeFields(jsonLdFields, citationFields, dcFields, ogFields, htmlFields);
+  const now = /* @__PURE__ */ new Date();
+  const accessed = {
+    "date-parts": [[now.getFullYear(), now.getMonth() + 1, now.getDate()]]
+  };
+  const item = {
+    id: "",
+    type: merged.type || "webpage",
+    title: merged.title || pageUrl,
+    URL: pageUrl,
+    accessed
+  };
+  if (merged.author?.length) item.author = merged.author;
+  if (merged.issued) item.issued = merged.issued;
+  if (merged.DOI) item.DOI = merged.DOI;
+  if (merged["container-title"]) item["container-title"] = merged["container-title"];
+  if (merged.publisher) item.publisher = merged.publisher;
+  if (merged.abstract) item.abstract = merged.abstract;
+  return item;
+}
+function getReadabilityPath() {
+  const require2 = createRequire(import.meta.url);
+  return require2.resolve("@mozilla/readability/Readability.js");
+}
+let readabilityScriptCache;
+function getReadabilityScript() {
+  if (readabilityScriptCache === void 0) {
+    readabilityScriptCache = readFileSync(getReadabilityPath(), "utf-8");
+  }
+  return readabilityScriptCache;
+}
+async function processPage(page, url, options) {
+  const warnings = [];
+  await page.goto(url, {
+    waitUntil: "domcontentloaded",
+    timeout: options.timeout * 1e3
+  });
+  await page.waitForLoadState("networkidle", { timeout: 2e3 }).catch(() => {
+  });
+  try {
+    const readabilityScript = getReadabilityScript();
+    await page.addScriptTag({ content: readabilityScript });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    warnings.push(`Readability injection failed: ${msg}`);
+  }
+  const item = await extractMetadata(page);
+  const fulltext = await generateFulltext(page);
+  let archive;
+  if (!options.noArchive) {
+    try {
+      archive = await createArchive(page, options.archiveFormat);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      warnings.push(`Archive creation failed: ${msg}`);
+    }
+  }
+  return { item, fulltext, archive, warnings };
+}
+function resolvePageOptions(options) {
+  return {
+    archiveFormat: options.archiveFormat ?? options.urlConfig.archiveFormat,
+    noArchive: options.noArchive ?? false,
+    timeout: options.urlConfig.timeout
+  };
+}
+async function fetchUrl(url, options) {
+  const browser = await launchBrowser(options.urlConfig);
+  try {
+    const page = await browser.newPage();
+    try {
+      return await processPage(page, url, resolvePageOptions(options));
+    } finally {
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+  }
+}
+async function fetchUrls(urls, options) {
+  const results = /* @__PURE__ */ new Map();
+  if (urls.length === 0) {
+    return results;
+  }
+  let browser;
+  try {
+    browser = await launchBrowser(options.urlConfig);
+  } catch (error) {
+    for (const url of urls) {
+      results.set(url, error instanceof Error ? error : new Error(String(error)));
+    }
+    return results;
+  }
+  const pageOptions = resolvePageOptions(options);
+  try {
+    for (const url of urls) {
+      try {
+        const page = await browser.newPage();
+        try {
+          const result = await processPage(page, url, pageOptions);
+          results.set(url, result);
+        } finally {
+          await page.close();
+        }
+      } catch (error) {
+        results.set(url, error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  } finally {
+    await browser.close();
+  }
+  return results;
+}
 function classifyIdentifiers(identifiers) {
   const pmids = [];
   const dois = [];
@@ -12642,10 +13122,104 @@ async function processFile(filePath, options) {
     ];
   }
 }
+async function processUrlInput(url, options) {
+  if (!options.urlConfig) {
+    return {
+      success: false,
+      error: "URL import requires browser configuration. Set [url] section in config.",
+      source: url,
+      reason: "validation_error"
+    };
+  }
+  try {
+    const result = await fetchUrl(url, {
+      urlConfig: options.urlConfig,
+      archiveFormat: options.archiveFormat,
+      noArchive: options.noArchive
+    });
+    return {
+      success: true,
+      item: result.item,
+      source: url,
+      urlData: {
+        fulltext: result.fulltext,
+        archive: result.archive,
+        warnings: result.warnings
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: message,
+      source: url,
+      reason: "fetch_error"
+    };
+  }
+}
+async function processUrlInputs(urls, options) {
+  if (!options.urlConfig) {
+    return urls.map((url) => ({
+      success: false,
+      error: "URL import requires browser configuration. Set [url] section in config.",
+      source: url,
+      reason: "validation_error"
+    }));
+  }
+  if (urls.length === 1) {
+    const url = urls[0];
+    if (url) return [await processUrlInput(url, options)];
+    return [];
+  }
+  const fetchResults = await fetchUrls(urls, {
+    urlConfig: options.urlConfig,
+    archiveFormat: options.archiveFormat,
+    noArchive: options.noArchive
+  });
+  return urls.map((url) => {
+    const result = fetchResults.get(url);
+    if (!result) {
+      return {
+        success: false,
+        error: "URL was not processed",
+        source: url,
+        reason: "fetch_error"
+      };
+    }
+    if (result instanceof Error) {
+      return {
+        success: false,
+        error: result.message,
+        source: url,
+        reason: "fetch_error"
+      };
+    }
+    return {
+      success: true,
+      item: result.item,
+      source: url,
+      urlData: {
+        fulltext: result.fulltext,
+        archive: result.archive,
+        warnings: result.warnings
+      }
+    };
+  });
+}
 async function processIdentifiers(inputs, options) {
   const results = [];
   const validIdentifiers = [];
+  const urlInputs = [];
   for (const input of inputs) {
+    const pubmedId = extractPubmedId(input);
+    if (pubmedId !== null) {
+      validIdentifiers.push(pubmedId);
+      continue;
+    }
+    if (isUrl(input)) {
+      urlInputs.push(input);
+      continue;
+    }
     const isValidPmid = isPmid(input);
     const isValidDoi = isDoi(input);
     const isValidIsbn = isIsbn(input);
@@ -12666,6 +13240,10 @@ async function processIdentifiers(inputs, options) {
     const fetchResult = await importFromIdentifiers(validIdentifiers, options);
     results.push(...fetchResult.results);
   }
+  if (urlInputs.length > 0) {
+    const urlResults = await processUrlInputs(urlInputs, options);
+    results.push(...urlResults);
+  }
   return results;
 }
 async function importFromInputs(inputs, options) {
@@ -12736,17 +13314,40 @@ async function addReferences(inputs, library, options) {
     );
     if (processed.type === "failed") {
       failed.push(processed.item);
-    } else if (processed.type === "skipped") {
+      continue;
+    }
+    if (processed.type === "skipped") {
       skipped.push(processed.item);
-    } else {
-      added.push(processed.item);
+      continue;
     }
+    if (result.success && result.urlData) {
+      await handleUrlData(processed.item, result.urlData, library, options.attachmentsDirectory);
+    }
+    added.push(processed.item);
   }
   if (added.length > 0) {
     await library.save();
   }
   return { added, failed, skipped };
 }
+async function handleUrlData(addedItem, urlData, library, attachmentsDirectory) {
+  if (urlData.warnings.length > 0) {
+    addedItem.warnings = [...urlData.warnings];
+  }
+  if (attachmentsDirectory) {
+    try {
+      await saveUrlData(addedItem.id, urlData, library, attachmentsDirectory);
+    } catch (error) {
+      const message = `Failed to save URL data for ${addedItem.id}: ${error instanceof Error ? error.message : String(error)}`;
+      process.stderr.write(`${message}
+`);
+      if (!addedItem.warnings) {
+        addedItem.warnings = [];
+      }
+      addedItem.warnings.push(message);
+    }
+  }
+}
 function buildImportOptions(options) {
   const importOptions = {};
   if (options.format !== void 0) {
@@ -12758,6 +13359,15 @@ function buildImportOptions(options) {
   if (options.stdinContent !== void 0) {
     importOptions.stdinContent = options.stdinContent;
   }
+  if (options.urlConfig !== void 0) {
+    importOptions.urlConfig = options.urlConfig;
+  }
+  if (options.archiveFormat !== void 0) {
+    importOptions.archiveFormat = options.archiveFormat;
+  }
+  if (options.noArchive !== void 0) {
+    importOptions.noArchive = options.noArchive;
+  }
   return importOptions;
 }
 async function processImportResult(result, existingItems, addedIds, force, library) {
@@ -12803,6 +13413,52 @@ async function processImportResult(result, existingItems, addedIds, force, libra
   }
   return { type: "added", item: addedItem };
 }
+async function saveUrlData(id, urlData, library, attachmentsDirectory) {
+  if (urlData.fulltext) {
+    let tempDir;
+    try {
+      tempDir = mkdtempSync(join(tmpdir(), "refmgr-url-ft-"));
+      const fulltextPath = join(tempDir, "fulltext.md");
+      writeFileSync(fulltextPath, urlData.fulltext, "utf-8");
+      await addAttachment(library, {
+        identifier: id,
+        filePath: fulltextPath,
+        role: "fulltext",
+        move: true,
+        force: true,
+        idType: "id",
+        attachmentsDirectory
+      });
+    } finally {
+      if (tempDir) {
+        await rm(tempDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    }
+  }
+  if (urlData.archive) {
+    let tempDir;
+    try {
+      tempDir = mkdtempSync(join(tmpdir(), "refmgr-url-ar-"));
+      const archivePath = join(tempDir, `archive.${urlData.archive.extension}`);
+      writeFileSync(archivePath, urlData.archive.data, "utf-8");
+      await addAttachment(library, {
+        identifier: id,
+        filePath: archivePath,
+        role: "archive",
+        move: true,
+        force: false,
+        idType: "id",
+        attachmentsDirectory
+      });
+    } finally {
+      if (tempDir) {
+        await rm(tempDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    }
+  }
+}
 function generateSuffix(index) {
   const alphabet = "abcdefghijklmnopqrstuvwxyz";
   let suffix = "";
@@ -12873,7 +13529,7 @@ function createAddRoute(library, config) {
 }
 const CHECK_CONCURRENCY = 5;
 async function checkReferences(library, options) {
-  const { checkReference } = await import("./checker-kVM4S67y.js");
+  const { checkReference } = await import("./checker-CnWQe7v2.js");
   const save = options.save !== false;
   const skipDays = options.skipDays ?? 7;
   const items = await resolveItems(library, options);
@@ -13566,4 +14222,4 @@ export {
   createServer as y,
   fetch$1 as z
 };
-//# sourceMappingURL=index-B4-i4PrU.js.map
+//# sourceMappingURL=index-a52FHX03.js.map