@a9i5k4/dsh-literature 0.1.0

package/lib/index.js

@@ -0,0 +1,2347 @@
+/* @a9i5k4/dsh-literature — DSH host half. Generated by build.mjs, do not edit. */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// src/node/http.js
+var http_exports = {};
+__export(http_exports, {
+  isLoopbackRequest: () => isLoopbackRequest,
+  parseRange: () => parseRange,
+  readJsonBody: () => readJsonBody,
+  readRawBody: () => readRawBody,
+  responseClosed: () => responseClosed,
+  writeJson: () => writeJson,
+  writeSseEvent: () => writeSseEvent,
+  writeSseHead: () => writeSseHead,
+  writeText: () => writeText
+});
+import { once } from "node:events";
+function isLoopbackRequest(req) {
+  const remote = req.socket?.remoteAddress ?? "";
+  return remote === "127.0.0.1" || remote === "::1" || remote === "::ffff:127.0.0.1";
+}
+function writeJson(res, status, body) {
+  const payload = Buffer.from(JSON.stringify(body), "utf8");
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": payload.length,
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+function writeText(res, status, text) {
+  const payload = Buffer.from(text, "utf8");
+  res.writeHead(status, {
+    "content-type": "text/plain; charset=utf-8",
+    "content-length": payload.length,
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+async function readBody(req, limit) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > limit) {
+      req.destroy();
+      throw new Error(`request body too large (limit ${limit} bytes)`);
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function readRawBody(req, limit = DEFAULT_LIMIT) {
+  if (req.method === "GET" || req.method === "HEAD") return Buffer.alloc(0);
+  return readBody(req, limit);
+}
+async function readJsonBody(req, limit = 8 * 1024 * 1024) {
+  const raw = await readRawBody(req, limit);
+  if (raw.length === 0) return {};
+  try {
+    return JSON.parse(raw.toString("utf8"));
+  } catch {
+    throw new Error("request body is not valid JSON");
+  }
+}
+function responseClosed(res) {
+  return once(res, "close");
+}
+function writeSseHead(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive",
+    "x-accel-buffering": "no"
+  });
+  res.write("retry: 3000\n\n");
+}
+function writeSseEvent(res, id, event, data) {
+  if (id !== void 0) res.write(`id: ${id}
+`);
+  res.write(`event: ${event}
+`);
+  res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+function parseRange(header, total) {
+  if (!header) return null;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+  if (!m) return null;
+  const [, startRaw, endRaw] = m;
+  if (startRaw === "" && endRaw === "") return null;
+  let start;
+  let end;
+  if (startRaw === "") {
+    const suffix = Number(endRaw);
+    start = Math.max(0, total - suffix);
+    end = total - 1;
+  } else {
+    start = Number(startRaw);
+    end = endRaw === "" ? total - 1 : Math.min(Number(endRaw), total - 1);
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= total) {
+    return { invalid: true, total };
+  }
+  return { start, end, total };
+}
+var DEFAULT_LIMIT;
+var init_http = __esm({
+  "src/node/http.js"() {
+    DEFAULT_LIMIT = 64 * 1024 * 1024;
+  }
+});
+
+// src/node/config.js
+import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+// src/node/log.js
+var PREFIX = "[dsh-literature]";
+function log(...args) {
+  console.log(PREFIX, ...args);
+}
+function warn(...args) {
+  console.warn(PREFIX, ...args);
+}
+function error(...args) {
+  console.error(PREFIX, ...args);
+}
+
+// src/node/config.js
+function dshHome() {
+  const fromEnv = process.env.DSH_HOME || process.env.DSH_CONFIG_DIR;
+  if (fromEnv) return resolve(fromEnv);
+  return resolve(homedir(), ".dsh");
+}
+var CONFIG_PATH = join(dshHome(), "dsh-literature.json");
+var STORE_DIR = join(dshHome(), "storages", "dsh-literature");
+var PDF_DIR = join(STORE_DIR, "pdfs");
+var STORE_PATH = join(STORE_DIR, "store.json");
+var DEFAULTS = {
+  version: 1,
+  /** 'zotero' writes through the Connector API; 'dir' exports to `dirPath`. */
+  saveMode: "zotero",
+  dirPath: "",
+  /** Collection names the user wants new items to land in. Advisory only — the
+   *  Connector API saves into whatever the Zotero pane currently has selected. */
+  preferredCollections: [],
+  preferredTags: [],
+  /** Filename template for the 'dir' channel. */
+  naming: "{author}_{year}_{title}",
+  /** Fallback: regex-scan model replies for identifiers. Off by default. */
+  autoScanSession: false,
+  /** Unpaywall requires a contact email in the query string. */
+  unpaywallEmail: "",
+  retry: { maxAttempts: 3, baseDelayMs: 800, maxDelayMs: 8e3 },
+  fetchTimeoutMs: 3e4,
+  zoteroPort: 23119,
+  /** Overrides automatic data-dir detection from the Zotero profile prefs. */
+  dataDirOverride: ""
+};
+function merge(base, patch) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch ?? {})) {
+    if (v && typeof v === "object" && !Array.isArray(v) && typeof base[k] === "object" && base[k] !== null && !Array.isArray(base[k])) {
+      out[k] = merge(base[k], v);
+    } else if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var cached = null;
+async function loadConfig() {
+  if (cached) return cached;
+  let raw = null;
+  try {
+    raw = JSON.parse(await readFile(CONFIG_PATH, "utf8"));
+  } catch {
+    raw = null;
+  }
+  cached = merge(DEFAULTS, raw);
+  return cached;
+}
+async function saveConfig(patch) {
+  const next = merge(await loadConfig(), patch);
+  cached = next;
+  await mkdir(dirname(CONFIG_PATH), { recursive: true });
+  const tmp = `${CONFIG_PATH}.tmp`;
+  await writeFile(tmp, JSON.stringify(next, null, 2), "utf8");
+  await rename(tmp, CONFIG_PATH);
+  return next;
+}
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  await writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
+  await rename(tmp, path);
+}
+async function readJsonOrNull(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function ensureDirs() {
+  await mkdir(PDF_DIR, { recursive: true });
+  log("storage ready at", STORE_DIR);
+}
+
+// src/node/store/db.js
+var EMPTY = { version: 1, items: {}, tasks: {}, annotations: {} };
+var state = null;
+var flushTimer = null;
+var flushing = null;
+async function load() {
+  if (state) return state;
+  const raw = await readJsonOrNull(STORE_PATH);
+  state = raw && raw.version === 1 ? { ...EMPTY, ...raw } : { ...EMPTY };
+  return state;
+}
+function scheduleFlush() {
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flushing = persist().catch((e) => warn("persist failed:", e.message));
+  }, 250);
+  flushTimer.unref?.();
+}
+async function persist() {
+  const snapshot = state ?? await load();
+  await writeJsonAtomic(STORE_PATH, snapshot);
+}
+async function flush() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  await persist();
+  if (flushing) {
+    await flushing;
+    flushing = null;
+  }
+}
+async function getItem(key) {
+  return (await load()).items[key] ?? null;
+}
+async function listItems() {
+  const s = await load();
+  return Object.values(s.items).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+}
+async function putItem(item) {
+  const s = await load();
+  const prev = s.items[item.key];
+  const next = { ...prev, ...item, updatedAt: Date.now() };
+  next.createdAt = prev?.createdAt ?? item.createdAt ?? Date.now();
+  s.items[item.key] = next;
+  scheduleFlush();
+  return next;
+}
+async function patchItem(key, patch) {
+  const s = await load();
+  const prev = s.items[key];
+  if (!prev) return null;
+  const next = { ...prev, ...patch, updatedAt: Date.now() };
+  s.items[key] = next;
+  scheduleFlush();
+  return next;
+}
+async function removeItem(key) {
+  const s = await load();
+  delete s.items[key];
+  delete s.annotations[key];
+  scheduleFlush();
+}
+async function putTask(task) {
+  const s = await load();
+  s.tasks[task.id] = { ...s.tasks[task.id], ...task, updatedAt: Date.now() };
+  scheduleFlush();
+  return s.tasks[task.id];
+}
+async function listTasks() {
+  return Object.values((await load()).tasks).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+}
+async function getAnnotations(key) {
+  return (await load()).annotations[key] ?? [];
+}
+async function addAnnotation(key, annotation) {
+  const s = await load();
+  const list = s.annotations[key] ?? [];
+  const next = { id: annotation.id ?? `an_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`, createdAt: Date.now(), ...annotation };
+  list.push(next);
+  s.annotations[key] = list;
+  scheduleFlush();
+  return next;
+}
+async function patchAnnotation(key, id, patch) {
+  const s = await load();
+  const list = s.annotations[key] ?? [];
+  const idx = list.findIndex((a) => a.id === id);
+  if (idx === -1) return null;
+  list[idx] = { ...list[idx], ...patch, updatedAt: Date.now() };
+  scheduleFlush();
+  return list[idx];
+}
+async function removeAnnotation(key, id) {
+  const s = await load();
+  s.annotations[key] = (s.annotations[key] ?? []).filter((a) => a.id !== id);
+  scheduleFlush();
+}
+async function pruneFinishedTasks(olderThanMs = 24 * 3600 * 1e3) {
+  const s = await load();
+  const cutoff = Date.now() - olderThanMs;
+  let removed = 0;
+  for (const [id, t] of Object.entries(s.tasks)) {
+    if (t.state === "done" || t.state === "failed" || t.state === "cancelled") {
+      if ((t.updatedAt ?? 0) < cutoff) {
+        delete s.tasks[id];
+        removed += 1;
+      }
+    }
+  }
+  if (removed) scheduleFlush();
+  return removed;
+}
+async function init() {
+  await load();
+  await pruneFinishedTasks();
+  log("shadow store loaded");
+}
+
+// src/node/sse.js
+init_http();
+var clients = /* @__PURE__ */ new Set();
+var counter = 0;
+function addClient(res) {
+  clients.add(res);
+  return () => clients.delete(res);
+}
+function clientCount() {
+  return clients.size;
+}
+function emit(event, data) {
+  counter += 1;
+  for (const res of clients) {
+    if (res.writableEnded || res.destroyed) {
+      clients.delete(res);
+      continue;
+    }
+    try {
+      writeSseEvent(res, counter, event, data);
+    } catch (e) {
+      warn("sse write failed, dropping client:", e.message);
+      clients.delete(res);
+    }
+  }
+}
+function emitItem(item) {
+  emit("item", item);
+}
+function emitTask(task) {
+  emit("task", task);
+}
+function startHeartbeat(intervalMs = 2e4) {
+  const timer = setInterval(() => {
+    for (const res of clients) {
+      if (res.writableEnded || res.destroyed) {
+        clients.delete(res);
+        continue;
+      }
+      try {
+        res.write(": keep-alive\n\n");
+      } catch {
+        clients.delete(res);
+      }
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+// src/node/routes.js
+init_http();
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+
+// src/node/pipeline.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { writeFile as writeFile3, unlink, mkdir as mkdir3 } from "node:fs/promises";
+import { join as join4, dirname as dirname2 } from "node:path";
+
+// src/node/extract/identifiers.js
+var TRIM_RIGHT = /[.,;:!?。、，；：！？…—>'">）》\]]+$/;
+var CJK_PUNCT = "\u3002\u3001\uFF0C\uFF1B\uFF1A\uFF01\uFF1F\uFF08\uFF09\u3010\u3011\u300A\u300B\u3008\u3009\u2026\u2014\uFF5E\xB7";
+function trimRight(s) {
+  let out = s;
+  for (; ; ) {
+    const next = out.replace(TRIM_RIGHT, "");
+    const last = next[next.length - 1];
+    if ((last === ")" || last === "]" || last === "}" || last === "\uFF09" || last === "\u3011") && !next.slice(0, -1).includes(last === ")" ? "(" : last === "]" ? "[" : last === "}" ? "{" : last === "\uFF09" ? "\uFF08" : "\u3010")) {
+      out = next;
+      continue;
+    }
+    if (next === out) return next;
+    out = next;
+  }
+}
+var DOI_TAIL = `[^\\s"'<>\`|${CJK_PUNCT}]+`;
+var DOI_CORE = new RegExp(`10\\.\\d{4,9}\\/${DOI_TAIL}`, "gi");
+var DOI_HINT = new RegExp(`(?:https?:\\/\\/)?(?:dx\\.)?doi\\.org\\/(10\\.\\d{4,9}\\/${DOI_TAIL})`, "gi");
+var DOI_LABEL = new RegExp(`\\bDOI\\s*[:\uFF1A]\\s*(10\\.\\d{4,9}\\/${DOI_TAIL})`, "gi");
+var ARXIV_NEW = /\barXiv\s*[:. ]?\s*(\d{4}\.\d{4,5})(v\d+)?\b/gi;
+var ARXIV_OLD = /\barXiv\s*[:. ]?\s*([a-z][a-z-]*(?:\.[A-Z]{2})?\/\d{7})(v\d+)?\b/gi;
+var ARXIV_URL = /arxiv\.org\/(?:abs|pdf)\/([^\s"'?#>]+?)(?:\.pdf)?(?=[\s"'?#>()]|$)/gi;
+var PMID = /\bPMID\s*[:：]?\s*(\d{1,8})\b/gi;
+var ISBN = /\bISBN(?:-1[03])?\s*[:：]?\s*((?:97[89][-\s]?)?(?:\d[-\s]?){9}[\dXx])\b/gi;
+var QUOTED = /[“"「『]([^”"」』\n]{12,300})[”"」』]/g;
+var QUOTED_FALLBACK = /[‘'《]([^’'》\n]{12,300})[’'》]/g;
+function push(list, seen, entry) {
+  const dedupeKey = `${entry.kind}:${entry.value.toLowerCase()}`;
+  if (seen.has(dedupeKey)) return;
+  seen.add(dedupeKey);
+  list.push(entry);
+}
+function extractIdentifiers(text, options = {}) {
+  const src = typeof text === "string" ? text : "";
+  if (!src.trim()) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const linkTargets = [];
+  src.replace(/\]\(([^)\s]+)\)/g, (m, url) => {
+    linkTargets.push(url);
+    return m;
+  });
+  const scan = (source, offset = 0, confidenceBonus = 0) => {
+    let m;
+    DOI_HINT.lastIndex = 0;
+    while ((m = DOI_HINT.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "doi",
+        value: trimRight(m[1]),
+        display: trimRight(m[1]),
+        index: offset + m.index,
+        confidence: 0.98 + confidenceBonus
+      });
+    }
+    DOI_LABEL.lastIndex = 0;
+    while ((m = DOI_LABEL.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "doi",
+        value: trimRight(m[1]),
+        display: trimRight(m[1]),
+        index: offset + m.index,
+        confidence: 0.98 + confidenceBonus
+      });
+    }
+    DOI_CORE.lastIndex = 0;
+    while ((m = DOI_CORE.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "doi",
+        value: trimRight(m[0]),
+        display: trimRight(m[0]),
+        index: offset + m.index,
+        // A bare DOI in prose is still very likely real, just slightly riskier.
+        confidence: 0.9 + confidenceBonus
+      });
+    }
+    ARXIV_URL.lastIndex = 0;
+    while ((m = ARXIV_URL.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "arxiv",
+        value: trimRight(m[1]).replace(/\.pdf$/i, ""),
+        display: trimRight(m[1]).replace(/\.pdf$/i, ""),
+        index: offset + m.index,
+        confidence: 0.97 + confidenceBonus
+      });
+    }
+    ARXIV_NEW.lastIndex = 0;
+    while ((m = ARXIV_NEW.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "arxiv",
+        value: m[1] + (m[2] ?? ""),
+        display: m[1] + (m[2] ?? ""),
+        index: offset + m.index,
+        confidence: 0.95 + confidenceBonus
+      });
+    }
+    ARXIV_OLD.lastIndex = 0;
+    while ((m = ARXIV_OLD.exec(source)) !== null) {
+      push(out, seen, {
+        kind: "arxiv",
+        value: m[1] + (m[2] ?? ""),
+        display: m[1] + (m[2] ?? ""),
+        index: offset + m.index,
+        confidence: 0.95 + confidenceBonus
+      });
+    }
+    PMID.lastIndex = 0;
+    while ((m = PMID.exec(source)) !== null) {
+      push(out, seen, { kind: "pmid", value: m[1], display: m[1], index: offset + m.index, confidence: 0.9 + confidenceBonus });
+    }
+    ISBN.lastIndex = 0;
+    while ((m = ISBN.exec(source)) !== null) {
+      push(out, seen, { kind: "isbn", value: m[1].replace(/[-\s]/g, ""), display: m[1], index: offset + m.index, confidence: 0.85 + confidenceBonus });
+    }
+  };
+  scan(src);
+  for (const url of linkTargets) scan(url, 0, 0.02);
+  if (options.includeTitles !== false) {
+    for (const re of [QUOTED, QUOTED_FALLBACK]) {
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(src)) !== null) {
+        const value = m[1].trim();
+        if (/^10\.\d{4,9}\//.test(value)) continue;
+        if (!/[一-龥A-Za-z]/.test(value)) continue;
+        push(out, seen, { kind: "title", value, display: value, index: m.index, confidence: 0.45 });
+      }
+    }
+  }
+  return out.sort((a, b) => a.index - b.index);
+}
+
+// src/node/extract/dedupe.js
+function normalizeDoi(value) {
+  if (!value) return "";
+  return String(value).trim().replace(/^https?:\/\/(dx\.)?doi\.org\//i, "").replace(/^doi:\s*/i, "").replace(/[.,;。；]$/, "").toLowerCase();
+}
+function normalizeArxiv(value) {
+  if (!value) return "";
+  return String(value).trim().replace(/^https?:\/\/arxiv\.org\/(abs|pdf)\//i, "").replace(/\.pdf$/i, "").replace(/^arxiv:\s*/i, "").toLowerCase();
+}
+function arxivBase(value) {
+  return normalizeArxiv(value).replace(/v\d+$/, "");
+}
+function normalizeIsbn(value) {
+  return String(value ?? "").replace(/[-\s]/g, "").toUpperCase();
+}
+function titleFingerprint(title) {
+  if (!title) return "";
+  return String(title).toLowerCase().replace(/[‘’“”「」『』《》〈〉"'`]/g, "").replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ").trim().replace(/\s+/g, " ").slice(0, 80);
+}
+function identityKey({ doi, arxiv, isbn, pmid, title }) {
+  const d = normalizeDoi(doi);
+  if (d) return `doi:${d}`;
+  const a = arxivBase(arxiv);
+  if (a) return `arxiv:${a}`;
+  const i = normalizeIsbn(isbn);
+  if (i) return `isbn:${i}`;
+  if (pmid) return `pmid:${String(pmid)}`;
+  const t = titleFingerprint(title);
+  if (t) return `title:${t}`;
+  return "";
+}
+function aliasKeys({ doi, arxiv, isbn, pmid, title }) {
+  const keys = /* @__PURE__ */ new Set();
+  const d = normalizeDoi(doi);
+  const a = arxivBase(arxiv);
+  const i = normalizeIsbn(isbn);
+  const t = titleFingerprint(title);
+  if (d) keys.add(`doi:${d}`);
+  if (a) keys.add(`arxiv:${a}`);
+  if (i) keys.add(`isbn:${i}`);
+  if (pmid) keys.add(`pmid:${String(pmid)}`);
+  if (t) keys.add(`title:${t}`);
+  return [...keys];
+}
+function buildItem(meta) {
+  const doi = normalizeDoi(meta.doi) || "";
+  const arxiv = arxivBase(meta.arxiv) || "";
+  const isbn = normalizeIsbn(meta.isbn) || "";
+  const pmid = meta.pmid ? String(meta.pmid) : "";
+  const title = (meta.title ?? "").trim();
+  const base = { doi, arxiv, isbn, pmid, title };
+  const key = identityKey(base);
+  return {
+    key,
+    aliases: aliasKeys(base),
+    ...base,
+    authors: meta.authors ?? [],
+    year: meta.year ?? null,
+    container: meta.container ?? "",
+    publisher: meta.publisher ?? "",
+    abstract: meta.abstract ?? "",
+    url: meta.url ?? "",
+    itemType: meta.itemType ?? "journalArticle",
+    raw: meta.raw ?? meta
+  };
+}
+function sameWork(a, b) {
+  const ka = a.aliases ?? aliasKeys(a);
+  const kb = b.aliases ?? aliasKeys(b);
+  return ka.some((k) => kb.includes(k));
+}
+
+// src/node/net.js
+var UA = "dsh-literature/0.1 (+https://github.com/deepseek-ai/deepseek-harness)";
+var FetchFailure = class extends Error {
+  constructor(message, { code = "network", status = 0, retryable = true, cause } = {}) {
+    super(message, { cause });
+    this.name = "FetchFailure";
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+  }
+};
+async function httpGet(url, { timeoutMs = 3e4, headers = {}, accept, signal } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onAbort = () => controller.abort();
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      redirect: "follow",
+      signal: controller.signal,
+      headers: { "user-agent": UA, ...accept ? { accept } : {}, ...headers }
+    });
+    if (!res.ok) {
+      throw new FetchFailure(`GET ${url} -> HTTP ${res.status}`, {
+        code: res.status === 404 ? "not_found" : res.status === 403 || res.status === 401 ? "forbidden" : "network",
+        status: res.status,
+        retryable: res.status === 429 || res.status >= 500
+      });
+    }
+    return res;
+  } catch (e) {
+    if (e instanceof FetchFailure) throw e;
+    if (e?.name === "AbortError") {
+      throw new FetchFailure(`GET ${url} timed out after ${timeoutMs}ms`, { code: "timeout", retryable: true, cause: e });
+    }
+    throw new FetchFailure(`GET ${url} failed: ${e?.message ?? e}`, { code: "network", retryable: true, cause: e });
+  } finally {
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener("abort", onAbort);
+  }
+}
+async function httpGetJson(url, options = {}) {
+  const res = await httpGet(url, { accept: "application/json", ...options });
+  try {
+    return await res.json();
+  } catch (e) {
+    throw new FetchFailure(`GET ${url} returned non-JSON body`, { code: "bad_payload", retryable: false, cause: e });
+  }
+}
+async function httpGetText(url, options = {}) {
+  const res = await httpGet(url, options);
+  return res.text();
+}
+async function httpGetBuffer(url, options = {}) {
+  const res = await httpGet(url, options);
+  const buf = Buffer.from(await res.arrayBuffer());
+  return { buffer: buf, contentType: res.headers.get("content-type") ?? "", finalUrl: res.url || url };
+}
+async function withRetry(fn, { maxAttempts = 3, baseDelayMs = 800, maxDelayMs = 8e3, label = "operation", shouldRetry } = {}) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await fn(attempt);
+    } catch (e) {
+      lastError = e;
+      const retryable = shouldRetry ? shouldRetry(e) : e?.retryable !== false;
+      if (!retryable || attempt >= maxAttempts) break;
+      const delay = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+      const jitter = Math.round(delay * 0.2 * Math.random());
+      warn(`${label} attempt ${attempt}/${maxAttempts} failed (${e.message}); retrying in ${delay + jitter}ms`);
+      await new Promise((r) => setTimeout(r, delay + jitter));
+    }
+  }
+  throw lastError;
+}
+
+// src/node/metadata/crossref.js
+var BASE = "https://api.crossref.org";
+function splitName(name2) {
+  const s = (name2 ?? "").trim();
+  if (!s) return { firstName: "", lastName: "" };
+  if (s.includes(",")) {
+    const [last, first] = s.split(",").map((p) => p.trim());
+    return { firstName: first ?? "", lastName: last ?? "" };
+  }
+  const parts = s.split(/\s+/);
+  if (parts.length === 1) return { firstName: "", lastName: parts[0] };
+  return { firstName: parts.slice(0, -1).join(" "), lastName: parts[parts.length - 1] };
+}
+function yearOf(work) {
+  const parts = work.issued?.["date-parts"]?.[0];
+  if (Array.isArray(parts) && Number.isFinite(parts[0])) return parts[0];
+  const fromPrint = work["published-print"]?.["date-parts"]?.[0];
+  if (Array.isArray(fromPrint) && Number.isFinite(fromPrint[0])) return fromPrint[0];
+  const fromOnline = work["published-online"]?.["date-parts"]?.[0];
+  if (Array.isArray(fromOnline) && Number.isFinite(fromOnline[0])) return fromOnline[0];
+  return null;
+}
+function cleanText(s) {
+  return String(s ?? "").replace(/<jats:[^>]*>|<\/jats:[^>]*>/g, "").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+}
+var TYPE_MAP = {
+  "journal-article": "journalArticle",
+  "proceedings-article": "conferencePaper",
+  book: "book",
+  "book-chapter": "bookSection",
+  "book-part": "bookSection",
+  monograph: "book",
+  "edited-book": "book",
+  "reference-book": "book",
+  report: "report",
+  "report-component": "report",
+  dissertation: "thesis",
+  preprint: "preprint",
+  "posted-content": "preprint",
+  dataset: "dataset",
+  standard: "standard",
+  "journal-issue": "journalArticle",
+  "peer-review": "journalArticle"
+};
+function normalizeWork(work) {
+  if (!work) return null;
+  const authors2 = (work.author ?? []).map((a) => ({
+    creatorType: "author",
+    ...splitName(a.name ?? [a.given, a.family].filter(Boolean).join(" "))
+  }));
+  const editors = (work.editor ?? []).map((a) => ({
+    creatorType: "editor",
+    ...splitName(a.name ?? [a.given, a.family].filter(Boolean).join(" "))
+  }));
+  return {
+    source: "crossref",
+    itemType: TYPE_MAP[work.type] ?? "journalArticle",
+    title: Array.isArray(work.title) ? cleanText(work.title[0]) : cleanText(work.title),
+    authors: authors2.length ? authors2 : editors,
+    year: yearOf(work),
+    container: Array.isArray(work["container-title"]) ? cleanText(work["container-title"][0]) : cleanText(work["container-title"]),
+    publisher: cleanText(work.publisher),
+    volume: work.volume ?? "",
+    issue: work.issue ?? "",
+    pages: work.page ?? "",
+    doi: work.DOI ?? "",
+    isbn: Array.isArray(work.ISBN) ? work.ISBN[0] ?? "" : work.ISBN ?? "",
+    issn: Array.isArray(work.ISSN) ? work.ISSN[0] ?? "" : work.ISSN ?? "",
+    url: work.URL ?? (work.DOI ? `https://doi.org/${work.DOI}` : ""),
+    abstract: cleanText(work.abstract),
+    language: work.language ?? "",
+    raw: work
+  };
+}
+async function fetchByDoi(doi, { mailto, timeoutMs } = {}) {
+  const url = `${BASE}/works/${encodeURIComponent(doi.replace(/^https?:\/\/(dx\.)?doi\.org\//i, ""))}${mailto ? `?mailto=${encodeURIComponent(mailto)}` : ""}`;
+  const body = await httpGetJson(url, { timeoutMs });
+  return normalizeWork(body.message);
+}
+async function searchByTitle(title, { mailto, timeoutMs, rows = 3 } = {}) {
+  const params = new URLSearchParams({ "query.bibliographic": title, rows: String(rows), select: "DOI,title,author,issued,type,container-title,publisher,volume,issue,page,ISSN,ISBN,URL,abstract" });
+  if (mailto) params.set("mailto", mailto);
+  const body = await httpGetJson(`${BASE}/works?${params}`, { timeoutMs });
+  const items = (body.message?.items ?? []).map(normalizeWork).filter(Boolean);
+  if (!items.length) return [];
+  const wanted = title.toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ").trim();
+  return items.sort((a, b) => {
+    const fa = (a.title ?? "").toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ").trim();
+    const fb = (b.title ?? "").toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ").trim();
+    const da = fa && wanted && (fa.includes(wanted) || wanted.includes(fa)) ? 0 : 1;
+    const db = fb && wanted && (fb.includes(wanted) || wanted.includes(fb)) ? 0 : 1;
+    return da - db;
+  });
+}
+
+// src/node/metadata/arxiv.js
+var API = "https://export.arxiv.org/api/query";
+function decodeEntities(s) {
+  return String(s ?? "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function tag(block, name2) {
+  const m = new RegExp(`<${name2}(?:\\s[^>]*)?>([\\s\\S]*?)</${name2}>`, "i").exec(block);
+  return m ? decodeEntities(m[1]).replace(/\s+/g, " ").trim() : "";
+}
+function namespacesTag(block, name2) {
+  const m = new RegExp(`<[a-zA-Z-]+:${name2}(?:\\s[^>]*)?>([\\s\\S]*?)</[a-zA-Z-]+:${name2}>`, "i").exec(block);
+  return m ? decodeEntities(m[1]).trim() : "";
+}
+function authors(block) {
+  const out = [];
+  const re = /<author>([\s\S]*?)<\/author>/gi;
+  let m;
+  while ((m = re.exec(block)) !== null) {
+    const name2 = tag(m[1], "name");
+    if (!name2) continue;
+    const parts = name2.split(/\s+/);
+    out.push({
+      creatorType: "author",
+      firstName: parts.length > 1 ? parts.slice(0, -1).join(" ") : "",
+      lastName: parts[parts.length - 1]
+    });
+  }
+  return out;
+}
+function pdfUrl(block, entryId) {
+  const direct = /<link[^>]*title=["']pdf["'][^>]*href=["']([^"']+)["']/i.exec(block);
+  if (direct) return decodeEntities(direct[1]);
+  const byType = /<link[^>]*type=["']application\/pdf["'][^>]*href=["']([^"']+)["']/i.exec(block);
+  if (byType) return decodeEntities(byType[1]);
+  const clean = String(entryId ?? "").replace(/\/v\d+$/, "");
+  return clean ? `${clean.replace("http://", "https://")}.pdf` : "";
+}
+function normalizeEntry(block) {
+  const id = tag(block, "id");
+  const versioned = /abs\/(.+?)(?:v\d+)?$/i.exec(id)?.[1] ?? "";
+  const title = tag(block, "title");
+  if (!title) return null;
+  const published = tag(block, "published");
+  const year = published ? Number(published.slice(0, 4)) : null;
+  const journalRef = namespacesTag(block, "journal_ref");
+  return {
+    source: "arxiv",
+    itemType: journalRef ? "journalArticle" : "preprint",
+    title,
+    authors: authors(block),
+    year: Number.isFinite(year) ? year : null,
+    container: journalRef ? "" : "arXiv",
+    publisher: journalRef ? "" : "arXiv",
+    volume: "",
+    issue: "",
+    pages: "",
+    doi: namespacesTag(block, "doi") || "",
+    isbn: "",
+    issn: "",
+    url: id,
+    abstract: tag(block, "summary"),
+    arxiv: versioned,
+    pdfUrl: pdfUrl(block, id),
+    raw: { id, published, journalRef }
+  };
+}
+async function fetchById(id, { timeoutMs } = {}) {
+  const clean = String(id).replace(/^arxiv:/i, "").replace(/\.pdf$/i, "");
+  const url = `${API}?id_list=${encodeURIComponent(clean)}&max_results=1`;
+  const xml = await httpGetText(url, { timeoutMs });
+  const entry = /<entry>([\s\S]*?)<\/entry>/i.exec(xml);
+  if (!entry) return null;
+  return normalizeEntry(entry[1]);
+}
+async function searchByTitle2(title, { timeoutMs, rows = 3 } = {}) {
+  const url = `${API}?search_query=${encodeURIComponent(`all:"${title}"`)}&max_results=${rows}&sortBy=relevance`;
+  const xml = await httpGetText(url, { timeoutMs });
+  const out = [];
+  const re = /<entry>([\s\S]*?)<\/entry>/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const e = normalizeEntry(m[1]);
+    if (e) out.push(e);
+  }
+  return out;
+}
+
+// src/node/metadata/openalex.js
+var BASE2 = "https://api.openalex.org";
+var TYPE_MAP2 = {
+  article: "journalArticle",
+  book: "book",
+  "book-chapter": "bookSection",
+  editorial: "journalArticle",
+  letter: "journalArticle",
+  preprint: "preprint",
+  dataset: "dataset",
+  review: "journalArticle",
+  dissertation: "thesis",
+  "peer-review": "journalArticle",
+  "reference-entry": "journalArticle"
+};
+function reconstructAbstract(inverted) {
+  if (!inverted || typeof inverted !== "object") return "";
+  const slots = [];
+  for (const [word, positions] of Object.entries(inverted)) {
+    for (const p of positions) slots[p] = word;
+  }
+  return slots.filter(Boolean).join(" ").trim();
+}
+function normalizeWork2(work) {
+  if (!work) return null;
+  const authors2 = (work.authorships ?? []).map((a) => {
+    const name2 = (a.author?.display_name ?? "").trim();
+    const parts = name2.split(/\s+/);
+    return {
+      creatorType: "author",
+      firstName: parts.length > 1 ? parts.slice(0, -1).join(" ") : "",
+      lastName: parts[parts.length - 1] ?? name2
+    };
+  });
+  const loc = work.primary_location ?? work.best_oa_location ?? {};
+  const venue = loc.source ?? {};
+  const oa = work.best_oa_location ?? {};
+  const biblio = work.biblio ?? {};
+  return {
+    source: "openalex",
+    itemType: TYPE_MAP2[work.type] ?? "journalArticle",
+    title: (work.title ?? work.display_name ?? "").trim(),
+    authors: authors2,
+    year: work.publication_year ?? null,
+    container: venue.display_name ?? "",
+    publisher: venue.host_organization_name ?? "",
+    volume: biblio.volume ?? "",
+    issue: biblio.issue ?? "",
+    pages: [biblio.first_page, biblio.last_page].filter(Boolean).join("-"),
+    doi: (work.doi ?? "").replace(/^https?:\/\/(dx\.)?doi\.org\//i, ""),
+    isbn: Array.isArray(work.isbns) ? work.isbns[0] ?? "" : "",
+    issn: Array.isArray(venue.issn) ? venue.issn[0] ?? "" : venue.issn_l ?? "",
+    url: work.doi ?? work.id ?? "",
+    abstract: reconstructAbstract(work.abstract_inverted_index),
+    language: work.language_code ?? "",
+    openAccess: {
+      isOa: !!work.open_access?.is_oa,
+      pdfUrl: oa.pdf_url ?? "",
+      landingPageUrl: oa.landing_page_url ?? ""
+    },
+    raw: work
+  };
+}
+async function fetchByDoi2(doi, { mailto, timeoutMs } = {}) {
+  const clean = String(doi).replace(/^https?:\/\/(dx\.)?doi\.org\//i, "");
+  const url = `${BASE2}/works/doi:${encodeURIComponent(clean)}${mailto ? `?mailto=${encodeURIComponent(mailto)}` : ""}`;
+  try {
+    return normalizeWork2(await httpGetJson(url, { timeoutMs }));
+  } catch (e) {
+    if (e?.status === 404) return null;
+    throw e;
+  }
+}
+async function searchByTitle3(title, { mailto, timeoutMs, rows = 3 } = {}) {
+  const params = new URLSearchParams({ search: title, per_page: String(rows) });
+  if (mailto) params.set("mailto", mailto);
+  const body = await httpGetJson(`${BASE2}/works?${params}`, { timeoutMs });
+  return (body.results ?? []).map(normalizeWork2).filter(Boolean);
+}
+
+// src/node/metadata/index.js
+var ID_CONVERTER = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0/";
+async function pmidToDoi(pmid, timeoutMs) {
+  try {
+    const body = await httpGetJson(`${ID_CONVERTER}?ids=${encodeURIComponent(pmid)}&format=json`, { timeoutMs });
+    const rec = body?.records?.[0];
+    return rec?.doi ?? "";
+  } catch (e) {
+    warn("pmid -> doi conversion failed:", e.message);
+    return "";
+  }
+}
+async function firstResult(fn, label) {
+  try {
+    return await fn();
+  } catch (e) {
+    warn(`${label} lookup failed:`, e.message);
+    return null;
+  }
+}
+async function resolveIdentifier(id, { timeoutMs = 2e4, unpaywallEmail = "" } = {}) {
+  const mailto = unpaywallEmail || void 0;
+  if (id.kind === "doi") {
+    return await firstResult(() => fetchByDoi(id.value, { mailto, timeoutMs }), "crossref/doi") ?? await firstResult(() => fetchByDoi2(id.value, { mailto, timeoutMs }), "openalex/doi");
+  }
+  if (id.kind === "arxiv") {
+    const direct = await firstResult(() => fetchById(id.value, { timeoutMs }), "arxiv/id");
+    if (direct) {
+      if (direct.doi) {
+        const published = await firstResult(() => fetchByDoi(direct.doi, { mailto, timeoutMs }), "crossref/doi");
+        if (published) return { ...published, arxiv: direct.arxiv, pdfUrl: direct.pdfUrl, preprint: direct };
+      }
+      return direct;
+    }
+    return null;
+  }
+  if (id.kind === "pmid") {
+    const doi = await pmidToDoi(id.value, timeoutMs);
+    if (doi) {
+      const rec = await firstResult(() => fetchByDoi(doi, { mailto, timeoutMs }), "crossref/doi");
+      if (rec) return { ...rec, pmid: id.value };
+    }
+    return null;
+  }
+  if (id.kind === "isbn") {
+    return (await firstResult(() => searchByTitle3(id.value, { mailto, timeoutMs, rows: 1 }), "openalex/isbn"))?.[0] ?? null;
+  }
+  if (id.kind === "title") {
+    const cr = await firstResult(() => searchByTitle(id.value, { mailto, timeoutMs, rows: 3 }), "crossref/title");
+    if (cr?.length) return cr[0];
+    const ax = await firstResult(() => searchByTitle2(id.value, { timeoutMs, rows: 3 }), "arxiv/title");
+    if (ax?.length) return ax[0];
+    const oa = await firstResult(() => searchByTitle3(id.value, { mailto, timeoutMs, rows: 3 }), "openalex/title");
+    if (oa?.length) return oa[0];
+    return null;
+  }
+  return null;
+}
+
+// src/node/metadata/normalize.js
+var BASE_FIELDS = ["title", "abstractNote", "shortTitle", "url", "accessDate", "language", "rights", "extra", "DOI"];
+var TYPE_FIELDS = {
+  journalArticle: ["publicationTitle", "journalAbbreviation", "volume", "issue", "pages", "ISSN"],
+  book: ["publisher", "place", "edition", "numberOfVolumes", "ISBN", "series", "seriesNumber"],
+  bookSection: ["bookTitle", "publisher", "place", "edition", "pages", "ISBN", "series", "seriesNumber"],
+  conferencePaper: ["conferenceName", "proceedingsTitle", "publisher", "place", "pages", "DOI"],
+  preprint: ["repository", "archiveID", "publisher", "DOI"],
+  thesis: ["thesisType", "university", "place"],
+  report: ["reportNumber", "reportType", "institution", "place"],
+  dataset: ["repository", "publisher", "versionNumber"],
+  standard: ["organization", "publisher", "place"]
+};
+function cleanStr(v) {
+  if (v === null || v === void 0) return "";
+  return String(v).replace(/\s+/g, " ").trim();
+}
+function isoDate(record) {
+  if (record.year) return String(record.year);
+  const raw = cleanStr(record.date);
+  return raw;
+}
+function toZoteroItem(record, { clientId, tags = [], extra = "" } = {}) {
+  const itemType = TYPE_FIELDS[record.itemType] ? record.itemType : "journalArticle";
+  const allowed = /* @__PURE__ */ new Set([...BASE_FIELDS, ...TYPE_FIELDS[itemType]]);
+  const item = {
+    id: clientId,
+    itemType,
+    title: cleanStr(record.title) || "Untitled",
+    creators: (record.authors ?? []).filter((a) => a && (a.lastName || a.firstName)).map((a) => ({
+      creatorType: a.creatorType ?? "author",
+      firstName: cleanStr(a.firstName),
+      lastName: cleanStr(a.lastName)
+    }))
+  };
+  const set = (field, value) => {
+    if (!allowed.has(field)) return;
+    const v = cleanStr(value);
+    if (v) item[field] = v;
+  };
+  set("abstractNote", record.abstract);
+  set("DOI", record.doi);
+  set("ISBN", record.isbn);
+  set("ISSN", record.issn);
+  set("url", record.url);
+  set("language", record.language);
+  set("publisher", record.publisher);
+  set("volume", record.volume);
+  set("issue", record.issue);
+  set("pages", record.pages);
+  set("date", isoDate(record));
+  if (itemType === "journalArticle") set("publicationTitle", record.container);
+  if (itemType === "bookSection") set("bookTitle", record.container);
+  if (itemType === "conferencePaper") set("proceedingsTitle", record.container);
+  if (itemType === "preprint") {
+    set("repository", record.container || "arXiv");
+    set("archiveID", record.arxiv);
+  }
+  if (itemType === "dataset") set("repository", record.container);
+  item.accessDate = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
+  const extraParts = [];
+  if (record.arxiv) extraParts.push(`arXiv:${record.arxiv}`);
+  if (record.pmid) extraParts.push(`PMID: ${record.pmid}`);
+  if (extra) extraParts.push(extra);
+  if (extraParts.length) item.extra = extraParts.join("\n");
+  if (tags.length) item.tags = tags.map((t) => ({ tag: t }));
+  item.attachments = [];
+  return item;
+}
+function shortLabel(record) {
+  const authors2 = record.authors ?? [];
+  const first = authors2[0]?.lastName ?? "";
+  const suffix = authors2.length > 1 ? " \u7B49" : "";
+  const who = first ? `${first}${suffix}` : record.container || "\u672A\u547D\u540D";
+  const year = record.year ? ` ${record.year}` : "";
+  return `${who}${year}`.trim();
+}
+
+// src/node/fetch/pdf.js
+var PDF_MAGIC = Buffer.from("%PDF-", "latin1");
+var PdfFailure = class extends Error {
+  constructor(message, code, { retryable = false, detail } = {}) {
+    super(message);
+    this.name = "PdfFailure";
+    this.code = code;
+    this.retryable = retryable;
+    this.detail = detail;
+  }
+};
+function looksLikePdf(buffer) {
+  if (!buffer || buffer.length < 8) return false;
+  return buffer.subarray(0, 5).equals(PDF_MAGIC);
+}
+async function candidates(record, { unpaywallEmail } = {}) {
+  const out = [];
+  const push2 = (url, source, kind = "pdf") => {
+    if (!url) return;
+    out.push({ url: String(url), source, kind });
+  };
+  if (record.arxiv) {
+    const base = String(record.arxiv).replace(/v\d+$/, "");
+    push2(`https://arxiv.org/pdf/${base}`, "arXiv", "pdf");
+  }
+  if (record.pdfUrl) push2(record.pdfUrl, record.source ?? "metadata");
+  if (record.openAccess?.pdfUrl) push2(record.openAccess.pdfUrl, "OpenAlex OA", "pdf");
+  const doi = record.doi;
+  if (doi) {
+    try {
+      const oa = await httpGetJson(`https://api.openalex.org/works/doi:${encodeURIComponent(doi)}`, { timeoutMs: 1e4 });
+      const best = oa.best_oa_location ?? {};
+      push2(best.pdf_url, "OpenAlex OA", "pdf");
+      if (!best.pdf_url) push2(best.landing_page_url, "OpenAlex OA", "landing");
+    } catch (e) {
+      warn("openalex oa lookup failed:", e.message);
+    }
+    if (unpaywallEmail) {
+      try {
+        const body = await httpGetJson(`https://api.unpaywall.org/v2/${encodeURIComponent(doi)}?email=${encodeURIComponent(unpaywallEmail)}`, { timeoutMs: 15e3 });
+        const best = body.best_oa_location;
+        if (best) {
+          push2(best.url_for_pdf, "Unpaywall", "pdf");
+          push2(best.url, "Unpaywall", "landing");
+        }
+        for (const loc of body.oa_locations ?? []) {
+          push2(loc.url_for_pdf, "Unpaywall", "pdf");
+        }
+      } catch (e) {
+        warn("unpaywall lookup failed:", e.message);
+      }
+    }
+    push2(`https://doi.org/${encodeURIComponent(doi)}`, "DOI resolution", "landing");
+    try {
+      const cr = await httpGetJson(`https://api.crossref.org/works/${encodeURIComponent(doi)}`, { timeoutMs: 15e3 });
+      for (const link of cr.message?.link ?? []) {
+        if (link["content-type"] === "application/pdf") push2(link.URL, "Crossref link", "pdf");
+      }
+    } catch (e) {
+      warn("crossref link lookup failed:", e.message);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((c) => {
+    const k = c.url.toLowerCase();
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function extractPdfUrlFromHtml(html, baseUrl2) {
+  const re = /<meta[^>]+name=["']citation_pdf_url["'][^>]+content=["']([^"']+)["']/i.exec(html) ?? /<meta[^>]+content=["']([^"']+)["'][^>]+name=["']citation_pdf_url["']/i.exec(html);
+  if (re) {
+    try {
+      return new URL(re[1], baseUrl2).href;
+    } catch {
+    }
+  }
+  const link = /<link[^>]+rel=["']alternate["'][^>]+type=["']application\/pdf["'][^>]+href=["']([^"']+)["']/i.exec(html);
+  if (link) {
+    try {
+      return new URL(link[1], baseUrl2).href;
+    } catch {
+    }
+  }
+  return null;
+}
+async function fetchPdf(record, { timeoutMs = 3e4, unpaywallEmail = "" } = {}) {
+  const list = await candidates(record, { unpaywallEmail });
+  if (!list.length) {
+    throw new PdfFailure("\u6CA1\u6709\u53EF\u7528\u7684\u5168\u6587\u6765\u6E90", "no_source", { retryable: false });
+  }
+  const failures = [];
+  const pending = [...list];
+  while (pending.length) {
+    const cand = pending.shift();
+    try {
+      const { buffer, contentType, finalUrl } = await httpGetBuffer(cand.url, {
+        timeoutMs,
+        accept: "application/pdf,*/*;q=0.8"
+      });
+      if (looksLikePdf(buffer)) {
+        log(`pdf ok: ${cand.url} (${(buffer.length / 1024).toFixed(0)} KB via ${cand.source})`);
+        return { buffer, url: finalUrl || cand.url, source: cand.source };
+      }
+      const isHtml = /text\/html|application\/xhtml/i.test(contentType);
+      if (isHtml) {
+        const discovered = extractPdfUrlFromHtml(buffer.toString("utf8", 0, Math.min(buffer.length, 2 * 1024 * 1024)), finalUrl || cand.url);
+        if (discovered) {
+          pending.unshift({ url: discovered, source: `${cand.source} (PDF \u94FE\u63A5)`, kind: "pdf" });
+          continue;
+        }
+        failures.push({ url: cand.url, source: cand.source, reason: "landing page, no discoverable PDF link" });
+        continue;
+      }
+      failures.push({ url: cand.url, source: cand.source, reason: `unexpected content-type ${contentType || "unknown"}` });
+    } catch (e) {
+      if (e instanceof FetchFailure && e.code === "not_found") {
+        failures.push({ url: cand.url, source: cand.source, reason: "404" });
+        continue;
+      }
+      failures.push({ url: cand.url, source: cand.source, reason: e.message });
+    }
+  }
+  const sawLandingOnly = failures.length > 0 && failures.every((f) => /landing page|404/.test(f.reason));
+  throw new PdfFailure(
+    sawLandingOnly ? "\u8BE5\u6587\u732E\u6CA1\u6709\u5F00\u653E\u83B7\u53D6\u5168\u6587\uFF08\u53EF\u80FD\u662F\u4ED8\u8D39\u5899\uFF09" : "\u6240\u6709\u5168\u6587\u6765\u6E90\u5747\u4E0B\u8F7D\u5931\u8D25",
+    sawLandingOnly ? "paywalled" : "network",
+    { retryable: !sawLandingOnly, detail: failures }
+  );
+}
+
+// src/node/zotero/connector.js
+import { randomUUID } from "node:crypto";
+
+// src/node/zotero/data-dir.js
+import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { homedir as homedir2, platform } from "node:os";
+function appDataRoot() {
+  if (process.env.APPDATA) return process.env.APPDATA;
+  if (platform() === "win32") return join2(homedir2(), "AppData", "Roaming");
+  if (platform() === "darwin") return join2(homedir2(), "Library", "Application Support");
+  return join2(homedir2(), ".config");
+}
+function zoteroProfileRoot() {
+  return join2(appDataRoot(), "Zotero", "Zotero");
+}
+function unescapePath(value) {
+  return String(value).replace(/\\\\/g, "\\");
+}
+async function parseProfilesIni(root) {
+  try {
+    const ini = await readFile2(join2(root, "profiles.ini"), "utf8");
+    const profiles = [];
+    let current = null;
+    for (const rawLine of ini.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line.startsWith("[")) {
+        current = {};
+        profiles.push(current);
+        continue;
+      }
+      const eq = line.indexOf("=");
+      if (eq === -1 || !current) continue;
+      current[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
+    }
+    return profiles.filter((p) => p.Path && p.Name).sort((a, b) => (Number(b.Default) || 0) - (Number(a.Default) || 0));
+  } catch {
+    return [];
+  }
+}
+async function candidateProfileDirs() {
+  const root = zoteroProfileRoot();
+  const dirs = [];
+  for (const p of await parseProfilesIni(root)) {
+    dirs.push(resolve2(root, p.Path.replace(/\//g, "\\")));
+  }
+  try {
+    const profilesDir = join2(root, "Profiles");
+    for (const name2 of await readdir(profilesDir)) {
+      dirs.push(join2(profilesDir, name2));
+    }
+  } catch {
+  }
+  return dirs;
+}
+async function readDataDirFrom(dir) {
+  let text;
+  try {
+    text = await readFile2(join2(dir, "prefs.js"), "utf8");
+  } catch {
+    return null;
+  }
+  const m = /user_pref\(\s*["']extensions\.zotero\.dataDir["']\s*,\s*["']([^"']+)["']\s*\)/.exec(text);
+  return m ? unescapePath(m[1]) : null;
+}
+async function isValidDataDir(dir) {
+  if (!dir) return false;
+  try {
+    const s = await stat(join2(dir, "zotero.sqlite"));
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+var cached2 = null;
+async function resolveDataDir() {
+  if (cached2) return cached2;
+  const result = { dataDir: null, profileDir: null, source: "none" };
+  for (const dir of await candidateProfileDirs()) {
+    const dataDir = await readDataDirFrom(dir);
+    if (dataDir && await isValidDataDir(dataDir)) {
+      result.dataDir = dataDir;
+      result.profileDir = dir;
+      result.source = "prefs";
+      break;
+    }
+    if (dataDir && !result.dataDir) {
+      result.dataDir = dataDir;
+      result.profileDir = dir;
+      result.source = "prefs-unverified";
+    }
+  }
+  if (!result.dataDir) {
+    const fallback = join2(homedir2(), "Zotero");
+    if (await isValidDataDir(fallback)) {
+      result.dataDir = fallback;
+      result.source = "default";
+    }
+  }
+  if (result.source === "prefs-unverified") warn(`dataDir ${result.dataDir} has no zotero.sqlite`);
+  cached2 = result;
+  return result;
+}
+
+// src/node/zotero/health.js
+var CONNECTOR_API_VERSION = "3";
+function baseUrl(portOverride) {
+  return `http://127.0.0.1:${portOverride ?? 23119}`;
+}
+function connectorHeaders(extra = {}) {
+  return { "X-Zotero-Connector-API-Version": CONNECTOR_API_VERSION, "Content-Type": "application/json", ...extra };
+}
+async function ping({ port, timeoutMs = 1500 } = {}) {
+  const config = await loadConfig();
+  const url = `${baseUrl(port ?? config.zoteroPort)}/connector/ping`;
+  try {
+    const res = await httpGet(url, { timeoutMs });
+    const version = res.headers.get("x-zotero-version") ?? "";
+    await res.text().catch(() => "");
+    return { running: true, version, url: baseUrl(port ?? config.zoteroPort) };
+  } catch (e) {
+    return { running: false, version: "", url: baseUrl(port ?? config.zoteroPort), error: e.message, code: e.code ?? "network" };
+  }
+}
+async function describe() {
+  const config = await loadConfig();
+  const status = await ping();
+  const { dataDir, profileDir, source } = await resolveDataDir();
+  let library = null;
+  if (status.running) {
+    try {
+      const res = await httpGet(`${baseUrl(config.zoteroPort)}/api/users/0/items/top?limit=1&format=json`, {
+        timeoutMs: 3e3,
+        headers: { "Zotero-API-Version": "3" }
+      });
+      const total = res.headers.get("total-results");
+      await res.text().catch(() => "");
+      library = { readable: true, itemCount: total ? Number(total) : null };
+    } catch (e) {
+      library = { readable: false, error: e.message };
+    }
+  }
+  return {
+    running: status.running,
+    version: status.version,
+    endpoint: status.url,
+    dataDir: config.dataDirOverride || dataDir || "",
+    dataDirSource: config.dataDirOverride ? "override" : source,
+    profileDir,
+    library,
+    saveMode: config.saveMode
+  };
+}
+async function ensureZotero() {
+  const status = await ping();
+  if (!status.running) {
+    throw Object.assign(new Error("Zotero \u672A\u8FD0\u884C"), { code: "zotero_not_running" });
+  }
+  return status;
+}
+
+// src/node/zotero/connector.js
+async function request(path, { method = "POST", body, headers = {}, timeoutMs = 6e4 } = {}) {
+  await ensureZotero();
+  const config = await loadConfig();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${baseUrl(config.zoteroPort)}${path}`, {
+      method,
+      headers: connectorHeaders(headers),
+      body,
+      signal: controller.signal
+    });
+    return res;
+  } catch (e) {
+    if (e?.name === "AbortError") throw Object.assign(new Error(`Zotero \u8BF7\u6C42\u8D85\u65F6\uFF08${path}\uFF09`), { code: "timeout" });
+    throw Object.assign(new Error(`\u65E0\u6CD5\u8FDE\u63A5 Zotero\uFF08${path}\uFF09\uFF1A${e.message}`), { code: "network" });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function postJson(path, payload, options) {
+  const res = await request(path, { body: JSON.stringify(payload), ...options });
+  const text = await res.text().catch(() => "");
+  if (res.status === 409) {
+    throw Object.assign(new Error("Zotero \u4F1A\u8BDD\u51B2\u7A81\uFF0C\u8BF7\u91CD\u8BD5"), { code: "session_exists" });
+  }
+  if (res.status >= 400) {
+    let detail = text;
+    try {
+      detail = JSON.parse(text)?.error ?? text;
+    } catch {
+    }
+    throw Object.assign(new Error(`Zotero \u8FD4\u56DE ${res.status}: ${detail}`), { code: "zotero_error", status: res.status });
+  }
+  return { status: res.status, body: text };
+}
+async function postBuffer(path, buffer, { metadata, contentType, timeoutMs }) {
+  const headers = {
+    "Content-Type": contentType,
+    "Content-Length": String(buffer.length)
+  };
+  if (metadata) headers["X-Metadata"] = JSON.stringify(metadata);
+  const res = await request(path, { body: buffer, headers, timeoutMs });
+  const text = await res.text().catch(() => "");
+  if (res.status >= 400) {
+    let detail = text;
+    try {
+      detail = JSON.parse(text)?.error ?? text;
+    } catch {
+    }
+    throw Object.assign(new Error(`Zotero \u9644\u4EF6\u5199\u5165\u5931\u8D25 ${res.status}: ${detail}`), { code: "zotero_error", status: res.status });
+  }
+  return { status: res.status, body: text };
+}
+async function saveToZotero({ item, pdfBuffer, pdfFileName: pdfFileName2, pdfUrl: pdfUrl2, sessionID = randomUUID(), timeoutMs = 6e4 }) {
+  await postJson("/connector/saveItems", { sessionID, items: [item], uri: pdfUrl2 || item.url || "" }, { timeoutMs: 3e4 });
+  let attachmentSaved = false;
+  if (pdfBuffer && pdfBuffer.length) {
+    const metadata = {
+      sessionID,
+      parentItemID: item.id,
+      title: pdfFileName2 || "Full Text PDF",
+      url: pdfUrl2 || item.url || ""
+    };
+    await postBuffer(`/connector/saveAttachment?sessionID=${encodeURIComponent(sessionID)}`, pdfBuffer, {
+      metadata,
+      contentType: "application/pdf",
+      timeoutMs
+    });
+    attachmentSaved = true;
+  }
+  log(`saved to Zotero: ${item.title} (attachment: ${attachmentSaved})`);
+  return { sessionID, attachmentSaved };
+}
+async function getSelectedCollection() {
+  const res = await request("/connector/getSelectedCollection", { body: JSON.stringify({}), timeoutMs: 4e3 });
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+// src/node/exporter.js
+import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { join as join3, resolve as resolve3 } from "node:path";
+
+// src/node/zotero/naming.js
+var ILLEGAL = /[<>:"\/\\|?*\u0000-\u001f]/g;
+function safe(part) {
+  return String(part ?? "").replace(ILLEGAL, "").replace(/\s+/g, " ").trim();
+}
+function clampPart(part, max) {
+  const s = safe(part);
+  if (s.length <= max) return s;
+  return `${s.slice(0, Math.max(1, max - 1)).trimEnd()}\u2026`;
+}
+function firstAuthorLabel(authors2) {
+  const list = authors2 ?? [];
+  if (!list.length) return "Unknown";
+  const first = list[0];
+  const name2 = [first.lastName, first.firstName].filter(Boolean).join(", ");
+  return name2 || "Unknown";
+}
+function renderName(record, template = "{author}_{year}_{title}", { maxLength = 180 } = {}) {
+  const tokens = {
+    author: firstAuthorLabel(record.authors),
+    authors: (record.authors ?? []).map((a) => a.lastName).filter(Boolean).slice(0, 3).join("-") || "Unknown",
+    year: record.year ? String(record.year) : "n.d.",
+    title: record.title || "Untitled",
+    journal: record.container || record.publisher || "",
+    doi: (record.doi || "").replace(/[^\w.-]+/g, "_"),
+    arxiv: (record.arxiv || "").replace(/[^\w.-]+/g, "_")
+  };
+  let out = String(template);
+  for (const [key, value] of Object.entries(tokens)) {
+    out = out.replace(new RegExp(`\\{${key}\\}`, "g"), String(value));
+  }
+  if (!out.trim()) out = "{author}_{year}_{title}";
+  if (!out.trim()) out = "Untitled";
+  return clampPart(out, maxLength);
+}
+function pdfFileName(record, template) {
+  return `${renderName(record, template)}.pdf`;
+}
+
+// src/node/exporter.js
+function cslJson(record) {
+  const authors2 = (record.authors ?? []).map((a) => ({
+    family: a.lastName ?? "",
+    given: a.firstName ?? ""
+  }));
+  const type = {
+    journalArticle: "article-journal",
+    book: "book",
+    bookSection: "chapter",
+    conferencePaper: "paper-conference",
+    preprint: "manuscript",
+    thesis: "thesis",
+    report: "report",
+    dataset: "dataset"
+  }[record.itemType] ?? "article-journal";
+  return [
+    {
+      id: record.doi || record.arxiv || record.title || "item",
+      type,
+      title: record.title ?? "",
+      author: authors2,
+      issued: record.year ? { "date-parts": [[record.year]] } : void 0,
+      "container-title": record.container || void 0,
+      publisher: record.publisher || void 0,
+      volume: record.volume || void 0,
+      issue: record.issue || void 0,
+      page: record.pages || void 0,
+      DOI: record.doi || void 0,
+      ISBN: record.isbn || void 0,
+      ISSN: record.issn || void 0,
+      abstract: record.abstract || void 0,
+      URL: record.url || void 0,
+      note: record.arxiv ? `arXiv:${record.arxiv}` : void 0
+    }
+  ];
+}
+function risLine(tag2, value) {
+  return value ? `${tag2}  - ${String(value).replace(/[\r\n]+/g, " ")}` : null;
+}
+function ris(record) {
+  const typeMap = {
+    journalArticle: "JOUR",
+    book: "BOOK",
+    bookSection: "CHAP",
+    conferencePaper: "CONF",
+    preprint: "EJOUR",
+    thesis: "THES",
+    report: "RPRT",
+    dataset: "DATA"
+  };
+  const lines = [risLine("TY", typeMap[record.itemType] ?? "JOUR")];
+  for (const a of record.authors ?? []) {
+    lines.push(risLine("AU", [a.lastName, a.firstName].filter(Boolean).join(", ")));
+  }
+  lines.push(
+    risLine("TI", record.title),
+    risLine("JO", record.container),
+    risLine("PB", record.publisher),
+    risLine("VL", record.volume),
+    risLine("IS", record.issue),
+    risLine("SP", record.pages),
+    risLine("PY", record.year ? String(record.year) : ""),
+    risLine("AB", record.abstract),
+    risLine("DO", record.doi),
+    risLine("SN", record.isbn || record.issn),
+    risLine("UR", record.url),
+    risLine("ER", "")
+  );
+  return lines.filter(Boolean).join("\r\n") + "\r\n";
+}
+async function exportToDirectory(record, pdfBuffer) {
+  const config = await loadConfig();
+  const dir = resolve3(config.dirPath || "");
+  if (!dir) throw Object.assign(new Error("\u672A\u914D\u7F6E\u5BFC\u51FA\u76EE\u5F55"), { code: "no_dir" });
+  await mkdir2(dir, { recursive: true });
+  const base = pdfFileName(record, config.naming);
+  const stem = base.replace(/\.pdf$/i, "");
+  const pdfPath = join3(dir, base);
+  const jsonPath = join3(dir, `${stem}.csl.json`);
+  const risPath = join3(dir, `${stem}.ris`);
+  const safePaths = [pdfPath, jsonPath, risPath].map((p) => resolve3(dir, p.replace(/^.*[\\/]/, "")));
+  if (pdfBuffer?.length) await writeFile2(safePaths[0], pdfBuffer);
+  await writeFile2(safePaths[1], JSON.stringify(cslJson(record), null, 2), "utf8");
+  await writeFile2(safePaths[2], ris(record), "utf8");
+  return { dir, pdfPath: safePaths[0], jsonPath: safePaths[1], risPath: safePaths[2] };
+}
+
+// src/node/zotero/local-api.js
+function apiHeaders() {
+  return { "Zotero-API-Version": "3" };
+}
+async function call(path, { timeoutMs = 1e4, headers = {} } = {}) {
+  await ensureZotero();
+  const config = await loadConfig();
+  return httpGetJson(`${baseUrl(config.zoteroPort)}${path}`, { timeoutMs, headers: { ...apiHeaders(), ...headers } });
+}
+function unwrap(entry) {
+  return entry?.data ?? entry;
+}
+async function searchItems(query, { limit = 25, qmode = "everything" } = {}) {
+  const params = new URLSearchParams({ format: "json", qmode });
+  if (query) params.set("q", query);
+  if (limit) params.set("limit", String(limit));
+  const body = await call(`/api/users/0/items?${params}`);
+  return Array.isArray(body) ? body.map(unwrap) : [unwrap(body)];
+}
+async function listCollections() {
+  const body = await call("/api/users/0/collections?format=json");
+  return Array.isArray(body) ? body.map(unwrap) : [];
+}
+async function getFileBuffer(key) {
+  await ensureZotero();
+  const config = await loadConfig();
+  return httpGetBuffer(`${baseUrl(config.zoteroPort)}/api/users/0/items/${encodeURIComponent(key)}/file`, { timeoutMs: 6e4 });
+}
+async function findDuplicates({ doi, arxiv, title }) {
+  const queries = [];
+  if (doi) queries.push({ field: "DOI", value: String(doi).toLowerCase() });
+  if (arxiv) queries.push({ field: "extra", value: String(arxiv).toLowerCase() });
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const q of queries) {
+    try {
+      const items = await searchItems(q.value, { limit: 25 });
+      for (const item of items) {
+        const itemDoi = String(item.DOI ?? "").toLowerCase();
+        const extra = String(item.extra ?? "").toLowerCase();
+        const matched = q.field === "DOI" ? itemDoi === q.value : extra.includes(q.value);
+        if (!matched) continue;
+        if (seen.has(item.key)) continue;
+        seen.add(item.key);
+        hits.push(item);
+      }
+    } catch (e) {
+      warn(`duplicate search failed for ${q.field}:`, e.message);
+    }
+  }
+  if (!hits.length && title) {
+    try {
+      const items = await searchItems(title.slice(0, 80), { limit: 10, qmode: "titleCreatorYear" });
+      for (const item of items) {
+        const a = String(item.title ?? "").toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ");
+        const b = String(title).toLowerCase().replace(/[^\p{Script=Han}\p{L}\p{N}]+/gu, " ");
+        if (!a || !b) continue;
+        if (a.includes(b.slice(0, 40)) || b.includes(a.slice(0, 40))) {
+          if (seen.has(item.key)) continue;
+          seen.add(item.key);
+          hits.push(item);
+        }
+      }
+    } catch (e) {
+      warn("title duplicate search failed:", e.message);
+    }
+  }
+  return hits;
+}
+
+// src/node/pipeline.js
+var FAILURE_MESSAGES = {
+  no_source: "\u6CA1\u6709\u627E\u5230\u5F00\u653E\u83B7\u53D6\u7684\u5168\u6587\u6765\u6E90",
+  paywalled: "\u8BE5\u6587\u732E\u6CA1\u6709\u5F00\u653E\u83B7\u53D6\u5168\u6587\uFF08\u53EF\u80FD\u662F\u4ED8\u8D39\u5899\uFF09",
+  not_found: "\u6807\u8BC6\u7B26\u5728\u5143\u6570\u636E\u670D\u52A1\u4E2D\u67E5\u4E0D\u5230",
+  timeout: "\u8BF7\u6C42\u8D85\u65F6",
+  network: "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25",
+  zotero_not_running: "Zotero \u672A\u8FD0\u884C",
+  zotero_error: "Zotero \u8FD4\u56DE\u9519\u8BEF",
+  no_dir: "\u672A\u914D\u7F6E\u5BFC\u51FA\u76EE\u5F55",
+  no_metadata: "\u65E0\u6CD5\u89E3\u6790\u51FA\u5143\u6570\u636E"
+};
+function failure(code, message, extra = {}) {
+  return {
+    code,
+    message: message || FAILURE_MESSAGES[code] || "\u64CD\u4F5C\u5931\u8D25",
+    // Only transient conditions are worth a retry button.
+    retryable: !["paywalled", "no_source", "not_found", "no_dir", "no_metadata"].includes(code),
+    ...extra
+  };
+}
+function pdfPathFor(key) {
+  return join4(PDF_DIR, `${key.replace(/[^\w.-]+/g, "_")}.pdf`);
+}
+async function update(key, patch) {
+  const next = await patchItem(key, patch);
+  if (next) emitItem(next);
+  return next;
+}
+async function startTask(key, kind) {
+  const task = await putTask({
+    id: randomUUID2(),
+    key,
+    kind,
+    state: "running",
+    progress: 0,
+    message: "",
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  });
+  emitTask(task);
+  return task;
+}
+async function finishTask(task, state2, message) {
+  const next = await putTask({ id: task.id, state: state2, progress: 100, message });
+  emitTask(next);
+  return next;
+}
+async function scanText(text) {
+  const found = extractIdentifiers(text);
+  const existing = await listItems();
+  const created = [];
+  for (const hit of found) {
+    const provisional = buildItem({
+      doi: hit.kind === "doi" ? hit.value : "",
+      arxiv: hit.kind === "arxiv" ? hit.value : "",
+      isbn: hit.kind === "isbn" ? hit.value : "",
+      pmid: hit.kind === "pmid" ? hit.value : "",
+      title: hit.kind === "title" ? hit.value : ""
+    });
+    if (!provisional.key) continue;
+    const clash = existing.find((e) => sameWork(e, provisional)) ?? await getItem(provisional.key);
+    if (clash) continue;
+    const item = await putItem({
+      ...provisional,
+      kind: hit.kind,
+      rawValue: hit.value,
+      display: hit.display || hit.value,
+      confidence: hit.confidence,
+      state: "discovered",
+      createdAt: Date.now()
+    });
+    existing.push(item);
+    created.push(item);
+    emitItem(item);
+  }
+  return created;
+}
+async function resolveItem(key) {
+  const item = await getItem(key);
+  if (!item) throw failure("not_found", "\u6761\u76EE\u4E0D\u5B58\u5728");
+  if (item.record && item.state !== "resolve_failed") return item;
+  const task = await startTask(key, "resolve");
+  await update(key, { state: "resolving", error: null });
+  const config = await loadConfig();
+  try {
+    const record = await withRetry(
+      () => resolveIdentifier(
+        { kind: item.kind, value: item.rawValue || item.doi || item.arxiv || item.isbn || item.pmid || item.title },
+        { timeoutMs: 2e4, unpaywallEmail: config.unpaywallEmail }
+      ),
+      { ...config.retry, label: `resolve ${key}` }
+    );
+    if (!record) {
+      await update(key, { state: "resolve_failed", error: failure("no_metadata") });
+      await finishTask(task, "failed", "\u5143\u6570\u636E\u89E3\u6790\u5931\u8D25");
+      return getItem(key);
+    }
+    const merged = buildItem({ ...item, ...record });
+    const updated = await patchItem(key, {
+      ...merged,
+      key,
+      state: "resolved",
+      record,
+      error: null,
+      updatedAt: Date.now()
+    });
+    emitItem(updated);
+    await finishTask(task, "done", "\u5143\u6570\u636E\u89E3\u6790\u5B8C\u6210");
+    return updated;
+  } catch (e) {
+    const err = failure(e.code ?? "network", e.message);
+    await update(key, { state: "resolve_failed", error: err });
+    await finishTask(task, "failed", err.message);
+    return getItem(key);
+  }
+}
+async function fetchItemPdf(key) {
+  const item = await getItem(key);
+  if (!item) throw failure("not_found", "\u6761\u76EE\u4E0D\u5B58\u5728");
+  if (item.pdf?.path) return item;
+  if (!item.record) {
+    const resolved = await resolveItem(key);
+    if (!resolved?.record) throw failure("no_metadata");
+  }
+  const current = await getItem(key);
+  const task = await startTask(key, "fetch");
+  await update(key, { state: "fetching", error: null });
+  const config = await loadConfig();
+  try {
+    const result = await withRetry(
+      (attempt) => {
+        if (attempt > 1) emitTask({ id: task.id, state: "running", progress: 10, message: `\u7B2C ${attempt} \u6B21\u5C1D\u8BD5`, updatedAt: Date.now() });
+        return fetchPdf(current.record, { timeoutMs: config.fetchTimeoutMs, unpaywallEmail: config.unpaywallEmail });
+      },
+      { ...config.retry, label: `fetch ${key}` }
+    );
+    const path = pdfPathFor(key);
+    await mkdir3(dirname2(path), { recursive: true });
+    await writeFile3(path, result.buffer);
+    const updated = await patchItem(key, {
+      state: "fetched",
+      pdf: { path, size: result.buffer.length, source: result.source, url: result.url },
+      error: null,
+      updatedAt: Date.now()
+    });
+    emitItem(updated);
+    await finishTask(task, "done", `\u5168\u6587\u4E0B\u8F7D\u5B8C\u6210\uFF08${(result.buffer.length / 1024).toFixed(0)} KB\uFF09`);
+    return updated;
+  } catch (e) {
+    const err = failure(e.code ?? "network", e.message, { detail: e.detail });
+    await update(key, { state: "fetch_failed", error: err });
+    await finishTask(task, "failed", err.message);
+    return getItem(key);
+  }
+}
+async function previewConflict(key) {
+  const item = await getItem(key);
+  if (!item) return null;
+  const record = item.record;
+  if (!record) return null;
+  const status = await ping();
+  if (!status.running) return null;
+  const hits = await findDuplicates({ doi: record.doi, arxiv: record.arxiv, title: record.title });
+  if (!hits.length) return null;
+  const existing = hits[0];
+  const incoming = toZoteroItem(record, { clientId: "preview" });
+  const fields = ["title", "DOI", "publicationTitle", "volume", "issue", "pages", "date", "publisher", "abstractNote"];
+  const diff = [];
+  for (const f of fields) {
+    const before = String(existing[f] ?? "");
+    const after = String(incoming[f] ?? "");
+    if (before === after) continue;
+    diff.push({ field: f, before, after });
+  }
+  const beforeAuthors = (existing.creators ?? []).map((c) => `${c.lastName ?? ""}, ${c.firstName ?? ""}`.trim()).join("; ");
+  const afterAuthors = (incoming.creators ?? []).map((c) => `${c.lastName ?? ""}, ${c.firstName ?? ""}`.trim()).join("; ");
+  if (beforeAuthors !== afterAuthors) diff.push({ field: "creators", before: beforeAuthors, after: afterAuthors });
+  return { key: existing.key, existing, incoming, diff, candidates: hits };
+}
+async function saveItem(key, { mode, tags } = {}) {
+  const item = await getItem(key);
+  if (!item) throw failure("not_found", "\u6761\u76EE\u4E0D\u5B58\u5728");
+  if (!item.record) {
+    const resolved = await resolveItem(key);
+    if (!resolved?.record) throw failure("no_metadata");
+  }
+  const current = await getItem(key);
+  const task = await startTask(key, "save");
+  await update(key, { state: "saving", error: null });
+  const config = await loadConfig();
+  const wantMode = mode || config.saveMode;
+  try {
+    let result;
+    if (wantMode === "dir") {
+      let buffer = null;
+      if (current.pdf?.path) {
+        const { readFile: readFile4 } = await import("node:fs/promises");
+        buffer = await readFile4(current.pdf.path).catch(() => null);
+      }
+      result = await exportToDirectory(current.record, buffer);
+      const updated2 = await patchItem(key, { state: "saved", saveMode: "dir", export: result, error: null, updatedAt: Date.now() });
+      emitItem(updated2);
+      await finishTask(task, "done", "\u5DF2\u5BFC\u51FA\u5230\u76EE\u5F55");
+      return updated2;
+    }
+    let pdfBuffer = null;
+    if (current.pdf?.path) {
+      const { readFile: readFile4 } = await import("node:fs/promises");
+      pdfBuffer = await readFile4(current.pdf.path).catch(() => null);
+    }
+    if (!pdfBuffer) {
+      const fetched = await fetchItemPdf(key);
+      if (fetched?.pdf?.path) {
+        const { readFile: readFile4 } = await import("node:fs/promises");
+        pdfBuffer = await readFile4(fetched.pdf.path).catch(() => null);
+      }
+    }
+    const clientId = `dshz_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const zoteroItem = toZoteroItem(current.record, {
+      clientId,
+      tags: tags?.length ? tags : config.preferredTags
+    });
+    const saved = await saveToZotero({
+      item: zoteroItem,
+      pdfBuffer,
+      pdfFileName: pdfFileName(current.record, config.naming),
+      pdfUrl: current.pdf?.url || current.record.url || ""
+    });
+    let zoteroKey = null;
+    try {
+      const hits = await findDuplicates({ doi: current.record.doi, arxiv: current.record.arxiv, title: current.record.title });
+      zoteroKey = hits[0]?.key ?? null;
+    } catch (e) {
+      warn("post-save lookup failed:", e.message);
+    }
+    const updated = await patchItem(key, {
+      state: "saved",
+      saveMode: "zotero",
+      zotero: { key: zoteroKey, sessionID: saved.sessionID, attachmentSaved: saved.attachmentSaved },
+      error: null,
+      updatedAt: Date.now()
+    });
+    emitItem(updated);
+    await finishTask(task, "done", "\u5DF2\u4FDD\u5B58\u5230 Zotero");
+    return updated;
+  } catch (e) {
+    const err = failure(e.code ?? "network", e.message, { detail: e.detail });
+    await update(key, { state: "save_failed", error: err });
+    await finishTask(task, "failed", err.message);
+    return getItem(key);
+  }
+}
+async function discardItem(key) {
+  const item = await getItem(key);
+  if (item?.pdf?.path) {
+    await unlink(item.pdf.path).catch(() => {
+    });
+  }
+  await removeItem(key);
+  emit("removed", { key });
+}
+async function retryItem(key) {
+  const item = await getItem(key);
+  if (!item) return null;
+  if (item.state === "resolve_failed") return resolveItem(key);
+  if (item.state === "fetch_failed") return fetchItemPdf(key);
+  if (item.state === "save_failed") return saveItem(key);
+  return item;
+}
+
+// src/node/routes.js
+var PREFIX2 = "/api/dsh-literature";
+function pathOf(req) {
+  const u = new URL(req.url ?? "/", "http://127.0.0.1");
+  return u.pathname;
+}
+function methodOk(req, ...allowed) {
+  return allowed.includes(req.method);
+}
+function safePdfPath(key) {
+  const base = resolve4(PDF_DIR);
+  const candidate = resolve4(base, `${String(key).replace(/[^\w.-]+/g, "_")}.pdf`);
+  if (!candidate.startsWith(base)) return null;
+  return candidate;
+}
+async function handleState(res) {
+  const config = await loadConfig();
+  const zotero = await describe();
+  const items = await listItems();
+  const tasks = await listTasks().then((all) => all.filter((t) => t.state === "running"));
+  let selectedCollection = null;
+  if (zotero.running) {
+    selectedCollection = await getSelectedCollection().catch(() => null);
+  }
+  writeJson(res, 200, { config, zotero, items, tasks, selectedCollection });
+}
+async function handleEvents(req, res) {
+  writeSseHead(res);
+  const remove = addClient(res);
+  emit("hello", { ok: true, clients: clientCount() });
+  try {
+    await responseClosed(res);
+  } catch {
+  } finally {
+    remove();
+  }
+}
+async function servePdf(req, res, key) {
+  const path = safePdfPath(key);
+  if (!path) {
+    writeJson(res, 400, { error: "invalid key" });
+    return;
+  }
+  let buffer;
+  try {
+    buffer = await readFile3(path);
+  } catch {
+    writeJson(res, 404, { error: "pdf not downloaded yet" });
+    return;
+  }
+  const range = parseRange(req.headers.range, buffer.length);
+  if (range?.invalid) {
+    res.writeHead(416, { "content-range": `bytes */${buffer.length}`, "content-length": 0 });
+    res.end();
+    return;
+  }
+  if (range) {
+    const slice = buffer.subarray(range.start, range.end + 1);
+    res.writeHead(206, {
+      "content-type": "application/pdf",
+      "content-length": slice.length,
+      "content-range": `bytes ${range.start}-${range.end}/${buffer.length}`,
+      "accept-ranges": "bytes"
+    });
+    res.end(range ? slice : buffer);
+    return;
+  }
+  res.writeHead(200, {
+    "content-type": "application/pdf",
+    "content-length": buffer.length,
+    "accept-ranges": "bytes",
+    "cache-control": "private, max-age=300"
+  });
+  res.end(buffer);
+}
+async function serveZoteroPdf(res, key) {
+  try {
+    const { buffer } = await getFileBuffer(key);
+    res.writeHead(200, {
+      "content-type": "application/pdf",
+      "content-length": buffer.length,
+      "accept-ranges": "bytes"
+    });
+    res.end(buffer);
+  } catch (e) {
+    writeJson(res, 502, { error: e.message });
+  }
+}
+async function handleAnnotations(req, res, key) {
+  if (req.method === "GET") {
+    writeJson(res, 200, { annotations: await getAnnotations(key) });
+    return;
+  }
+  const body = await readJsonBody2(req);
+  if (req.method === "POST") {
+    const created = await addAnnotation(key, body ?? {});
+    writeJson(res, 201, { annotation: created });
+    return;
+  }
+  if (req.method === "PATCH") {
+    const updated = await patchAnnotation(key, body?.id, body?.patch ?? {});
+    writeJson(res, 200, { annotation: updated });
+    return;
+  }
+  if (req.method === "DELETE") {
+    const id = new URL(req.url ?? "/", "http://127.0.0.1").searchParams.get("id");
+    await removeAnnotation(key, id);
+    writeJson(res, 200, { ok: true });
+    return;
+  }
+  writeJson(res, 405, { error: "method not allowed" });
+}
+async function readJsonBody2(req) {
+  const { readJsonBody: read } = await Promise.resolve().then(() => (init_http(), http_exports));
+  return read(req);
+}
+async function handler(req, res) {
+  if (!isLoopbackRequest(req)) {
+    writeJson(res, 403, { error: "forbidden: loopback-only" });
+    return;
+  }
+  const path = pathOf(req);
+  if (!path.startsWith(PREFIX2)) {
+    writeJson(res, 404, { error: "not found" });
+    return;
+  }
+  const rest = path.slice(PREFIX2.length).replace(/^\/+/, "");
+  const parts = rest.split("/").filter(Boolean);
+  const head = parts[0] ?? "";
+  try {
+    if (head === "events" && methodOk(req, "GET")) {
+      await handleEvents(req, res);
+      return;
+    }
+    if (head === "state" && methodOk(req, "GET")) {
+      await handleState(res);
+      return;
+    }
+    if (head === "config" && methodOk(req, "GET", "POST")) {
+      if (req.method === "POST") {
+        const patch = await readJsonBody2(req);
+        const next = await saveConfig(patch ?? {});
+        writeJson(res, 200, { config: next });
+      } else {
+        writeJson(res, 200, { config: await loadConfig() });
+      }
+      return;
+    }
+    if (head === "scan" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const created = await scanText(String(body?.text ?? ""));
+      writeJson(res, 200, { created });
+      return;
+    }
+    if (head === "resolve" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const item = await resolveItem(String(body?.key ?? ""));
+      writeJson(res, 200, { item });
+      return;
+    }
+    if (head === "fetch" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const item = await fetchItemPdf(String(body?.key ?? ""));
+      writeJson(res, 200, { item });
+      return;
+    }
+    if (head === "retry" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const item = await retryItem(String(body?.key ?? ""));
+      writeJson(res, 200, { item });
+      return;
+    }
+    if (head === "save" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const item = await saveItem(String(body?.key ?? ""), { mode: body?.mode, tags: body?.tags });
+      writeJson(res, 200, { item });
+      return;
+    }
+    if (head === "diff" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      const conflict = await previewConflict(String(body?.key ?? ""));
+      writeJson(res, 200, { conflict });
+      return;
+    }
+    if (head === "discard" && methodOk(req, "POST")) {
+      const body = await readJsonBody2(req);
+      await discardItem(String(body?.key ?? ""));
+      writeJson(res, 200, { ok: true });
+      return;
+    }
+    if (head === "pdf" && parts[1] && methodOk(req, "GET", "HEAD")) {
+      await servePdf(req, res, parts[1]);
+      return;
+    }
+    if (head === "zotero") {
+      const sub = parts[1] ?? "";
+      if (sub === "collections" && methodOk(req, "GET")) {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const items = await listCollections();
+        writeJson(res, 200, { collections: items, selected: url.searchParams.get("selected") === "1" ? await getSelectedCollection().catch(() => null) : null });
+        return;
+      }
+      if (sub === "items" && methodOk(req, "GET")) {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const q = url.searchParams.get("q") ?? "";
+        const items = await searchItems(q, { limit: Number(url.searchParams.get("limit") ?? 25) });
+        writeJson(res, 200, { items });
+        return;
+      }
+      if (sub === "file" && parts[2] && methodOk(req, "GET")) {
+        await serveZoteroPdf(res, parts[2]);
+        return;
+      }
+      if (sub === "ping" && methodOk(req, "GET")) {
+        writeJson(res, 200, { status: await ping() });
+        return;
+      }
+    }
+    if (head === "annotations" && parts[1] && methodOk(req, "GET", "POST", "PATCH", "DELETE")) {
+      await handleAnnotations(req, res, parts[1]);
+      return;
+    }
+    writeJson(res, 404, { error: `unknown route: ${path}` });
+  } catch (e) {
+    warn(`route ${path} failed:`, e?.stack ?? e);
+    if (!res.headersSent) writeJson(res, 500, { error: e?.message ?? "internal error" });
+    else res.end();
+  }
+}
+function registerRoutes(ctx) {
+  const disposers = [ctx.webServer.register({ kind: "prefix", path: PREFIX2, handler })];
+  log(`routes mounted at ${PREFIX2}/`);
+  return disposers;
+}
+
+// src/node/tools.js
+function textResult(value) {
+  return {
+    schema: { type: "string" },
+    render: (_args, v) => [{ type: "text", text: String(v) }]
+  };
+}
+function registerTools(ctx) {
+  const disposers = [];
+  disposers.push(
+    ctx.tools.register({
+      name: "zotero_lookup",
+      description: "\u4ECE\u6587\u672C\u6216\u6807\u8BC6\u7B26\u4E2D\u8BC6\u522B\u5B66\u672F\u6587\u732E\uFF08DOI\u3001arXiv ID\u3001PMID\u3001ISBN\u3001\u6807\u9898\uFF09\uFF0C\u89E3\u6790\u5143\u6570\u636E\u5E76\u751F\u6210\u4FA7\u7A97\u6761\u76EE\u3002\u5F53\u4F60\u68C0\u7D22\u6216\u5F15\u7528\u6587\u732E\u5E76\u5E0C\u671B\u7528\u6237\u80FD\u5728\u4FA7\u8FB9\u680F\u9884\u89C8/\u4FDD\u5B58\u5168\u6587\u65F6\u8C03\u7528\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "\u5305\u542B\u6587\u732E\u6807\u8BC6\u7B26\u6216\u5F15\u7528\u6587\u672C\u7684\u7247\u6BB5" },
+          resolve: { type: "string", description: "\u662F\u5426\u7ACB\u5373\u8054\u7F51\u89E3\u6790\u5143\u6570\u636E\uFF0C\u9ED8\u8BA4 yes" }
+        },
+        required: []
+      },
+      output: textResult(),
+      timeoutMs: 12e4,
+      async execute(args) {
+        const text = String(args?.text ?? "");
+        if (!text.trim()) return "\u6CA1\u6709\u63D0\u4F9B\u6587\u672C\u3002";
+        const created = await scanText(text);
+        if (!created.length) return "\u672A\u8BC6\u522B\u5230\u65B0\u7684\u6587\u732E\u6761\u76EE\uFF08\u53EF\u80FD\u5DF2\u5B58\u5728\u4E8E\u4FA7\u7A97\uFF09\u3002";
+        const wantResolve = String(args?.resolve ?? "yes").toLowerCase() !== "no";
+        if (wantResolve) {
+          await Promise.all(created.map((i) => resolveItem(i.key).catch((e) => warn("resolve failed", e.message))));
+        }
+        const items = await Promise.all(created.map((i) => getItem(i.key)));
+        const lines = items.filter(Boolean).map((i) => `- ${i.record?.title || i.display} [${i.key}]`);
+        return `\u5DF2\u52A0\u5165\u4FA7\u7A97 ${items.length} \u6761\uFF1A
+${lines.join("\n")}`;
+      }
+    })
+  );
+  disposers.push(
+    ctx.tools.register({
+      name: "zotero_save",
+      description: "\u628A\u4FA7\u7A97\u4E2D\u5DF2\u8BC6\u522B\u7684\u6587\u732E\u4FDD\u5B58\u5230\u672C\u5730 Zotero \u5E93\u6216\u5BFC\u51FA\u76EE\u5F55\uFF08\u4F1A\u81EA\u52A8\u4E0B\u8F7D\u5168\u6587 PDF\uFF09\u3002",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "\u6761\u76EE key\uFF08\u6765\u81EA zotero_lookup \u7684\u8FD4\u56DE\uFF09" },
+          mode: { type: "string", description: "\u4FDD\u5B58\u65B9\u5F0F\uFF1Azotero \u6216 dir\uFF0C\u7F3A\u7701\u7528\u914D\u7F6E\u503C" },
+          tags: { type: "string", description: "\u9017\u53F7\u5206\u9694\u7684\u6807\u7B7E" }
+        },
+        required: ["key"]
+      },
+      output: textResult(),
+      timeoutMs: 3e5,
+      async execute(args) {
+        const key = String(args?.key ?? "");
+        if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
+        const tags = String(args?.tags ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+        const item = await saveItem(key, { mode: args?.mode, tags });
+        if (!item) return `\u627E\u4E0D\u5230\u6761\u76EE ${key}\u3002`;
+        if (item.state === "saved") {
+          return `\u5DF2\u4FDD\u5B58\uFF1A${shortLabel(item.record ?? {})}\uFF08${item.saveMode === "dir" ? item.export?.pdfPath : "Zotero \u5E93"}\uFF09`;
+        }
+        return `\u4FDD\u5B58\u5931\u8D25\uFF1A${item.error?.message ?? "\u672A\u77E5\u9519\u8BEF"}\uFF08${item.error?.code ?? "unknown"}\uFF09`;
+      }
+    })
+  );
+  log("tools registered: zotero_lookup, zotero_save");
+  return disposers;
+}
+
+// src/node/session-hook.js
+function blockText(block) {
+  if (block == null) return "";
+  if (typeof block === "string") return block;
+  if (typeof block.text === "string") return block.text;
+  if (typeof block.content === "string") return block.content;
+  if (Array.isArray(block.content)) return block.content.map(blockText).join("\n");
+  return "";
+}
+function messageText(message) {
+  if (!message) return "";
+  if (typeof message === "string") return message;
+  if (Array.isArray(message)) return message.map(blockText).join("\n");
+  if (Array.isArray(message.content)) return message.content.map(blockText).join("\n");
+  if (typeof message.content === "string") return message.content;
+  if (typeof message.text === "string") return message.text;
+  return "";
+}
+function textFromSessionEvent(event) {
+  if (!event || typeof event !== "object") return "";
+  const type = event.type;
+  const data = event.data ?? {};
+  if (type === "assistant/message") return messageText(data.message);
+  if (type === "user/message") return messageText(data.message);
+  if (type === "tool/result") {
+    const result = data.result ?? data;
+    return typeof result === "string" ? result : blockText(result);
+  }
+  return "";
+}
+function registerSessionHook(ctx) {
+  const disposers = [];
+  disposers.push(
+    ctx.on("session/event", (session, event) => {
+      const text = textFromSessionEvent(event);
+      if (!text || text.length < 20) return;
+      if (!extractIdentifiers(text).length) return;
+      checkConfig().then((config) => {
+        if (!config?.autoScanSession) return;
+        return scanText(text);
+      }).catch((e) => warn("session scan failed:", e.message));
+    })
+  );
+  log("session hook registered (autoScanSession gates it)");
+  return disposers;
+}
+var cachedConfig = null;
+var cachedAt = 0;
+async function checkConfig() {
+  const now = Date.now();
+  if (cachedConfig && now - cachedAt < 2e3) return cachedConfig;
+  cachedAt = now;
+  cachedConfig = await loadConfig();
+  return cachedConfig;
+}
+
+// src/node/index.js
+var name = "dsh-literature-pre";
+var inject = ["webServer", "tools"];
+function apply(ctx, config) {
+  const onUncaught = (e) => error("uncaught exception:", e?.stack ?? e);
+  const onUnhandled = (e) => error("unhandled rejection:", e?.stack ?? e);
+  process.on("uncaughtException", onUncaught);
+  process.on("unhandledRejection", onUnhandled);
+  const disposers = [];
+  ctx.effect(() => {
+    ensureDirs().then(() => init()).catch((e) => error("storage init failed:", e.message));
+  }, "dsh-literature: storage");
+  const ready = (async () => {
+    await ensureDirs();
+    await init();
+    disposers.push(...registerRoutes(ctx));
+    disposers.push(...registerTools(ctx));
+    try {
+      disposers.push(...registerSessionHook(ctx));
+    } catch (e) {
+      error("session hook unavailable:", e.message);
+    }
+    disposers.push(startHeartbeat());
+    log("dsh-literature host half ready");
+  })().catch((e) => error("dsh-literature startup failed:", e?.stack ?? e));
+  return () => {
+    ready.catch(() => {
+    });
+    for (const d of disposers.splice(0)) {
+      try {
+        d?.();
+      } catch (e) {
+        error("dispose failed:", e.message);
+      }
+    }
+    process.off("uncaughtException", onUncaught);
+    process.off("unhandledRejection", onUnhandled);
+    flush().catch(() => {
+    });
+    log("dsh-literature host half disposed");
+  };
+}
+export {
+  apply,
+  inject,
+  name
+};