smart-web-mcp 0.8.8 → 0.9.0

package/dist/smartfetch/academic-fallback.js

@@ -0,0 +1,777 @@
+import { configText } from "../settings.js";
+import { absolutizeUrl, configEnabled, dedupeUrls, extractMetaDescription, extractMetaName, extractMetaProperty, extractTitleFromHtml } from "../shared.js";
+import { fetchProviderJson } from "./provider-policy.js";
+function academicFallbackEnabled() {
+    return configEnabled("fetch.enableAcademicFallback", true);
+}
+function openAlexEnabled() {
+    return configEnabled("fetch.enableOpenAlex", true);
+}
+function europePmcEnabled() {
+    return configEnabled("fetch.enableEuropePmc", true);
+}
+function biorxivApiEnabled() {
+    return configEnabled("fetch.enableBiorxivApi", true);
+}
+function unpaywallEnabled() {
+    return configEnabled("fetch.enableUnpaywall", true);
+}
+function semanticScholarEnabled() {
+    return configEnabled("fetch.enableSemanticScholar", true);
+}
+function coreDiscoveryEnabled() {
+    return configEnabled("fetch.enableCoreDiscovery", true);
+}
+function unpaywallEmail() {
+    return normalizeSpace(configText("fetch.unpaywallEmail"));
+}
+function semanticScholarApiKey() {
+    return normalizeSpace(configText("fetch.semanticScholarApiKey"));
+}
+function coreApiKey() {
+    return normalizeSpace(configText("fetch.coreApiKey"));
+}
+function normalizeSpace(value) {
+    return String(value || "").replace(/\s+/g, " ").trim();
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function textValue(value) {
+    return normalizeSpace(String(value || ""));
+}
+function uniqueTexts(values) {
+    return Array.from(new Set(values.map((value) => normalizeSpace(value)).filter(Boolean)));
+}
+function httpUrl(value) {
+    const text = textValue(value);
+    return /^https?:\/\//i.test(text) ? text : "";
+}
+function personName(value) {
+    const person = objectValue(value);
+    const direct = textValue(person.name) || textValue(person.display_name);
+    if (direct)
+        return direct;
+    const given = textValue(person.given) || textValue(person.given_name) || textValue(person.first);
+    const family = textValue(person.family) || textValue(person.family_name) || textValue(person.last);
+    return normalizeSpace([given, family].filter(Boolean).join(" "));
+}
+function authorNames(value) {
+    return uniqueTexts(arrayValue(value).map((item) => personName(item)));
+}
+function collectUrlFields(value, keyPattern, out) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectUrlFields(item, keyPattern, out);
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === "string") {
+            if (keyPattern.test(key))
+                out.push(entry);
+            continue;
+        }
+        if (typeof entry === "number" || typeof entry === "boolean" || entry === null)
+            continue;
+        collectUrlFields(entry, keyPattern, out);
+    }
+}
+function parseTagAttributes(tag) {
+    const attributes = {};
+    const regex = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    for (const match of tag.matchAll(regex)) {
+        const name = String(match[1] || "").trim().toLowerCase();
+        if (!name || name === "meta" || name in attributes)
+            continue;
+        const value = match[2] ?? match[3] ?? match[4] ?? "";
+        attributes[name] = normalizeSpace(String(value || ""));
+    }
+    return attributes;
+}
+function allMetaNames(html, names) {
+    const wanted = new Set(names.map((name) => name.toLowerCase()));
+    const out = [];
+    for (const match of html.matchAll(/<meta\b[^>]*>/gi)) {
+        const attributes = parseTagAttributes(String(match[0] || ""));
+        const name = String(attributes.name || "").toLowerCase();
+        if (!wanted.has(name))
+            continue;
+        const value = normalizeSpace(attributes.content || "");
+        if (value)
+            out.push(value);
+    }
+    return uniqueTexts(out);
+}
+function looksLikePdfUrl(url) {
+    return /\/pdf\//i.test(url) || /\/pdf(?:$|[?#])/i.test(url) || /\.pdf(?:$|[?#])/i.test(url) || /[?&]pdf(?:=|%3d|$)/i.test(url);
+}
+function normalizeDoi(value) {
+    const decoded = decodeURIComponent(String(value || ""));
+    const match = decoded.match(/10\.\d{4,9}\/[-._;()/:A-Z0-9]+/i);
+    return normalizeSpace(String(match?.[0] || "")).replace(/[)>.,;]+$/g, "");
+}
+function doiLinkUrl(doi) {
+    return doi ? `https://doi.org/${doi}` : "";
+}
+function extractDoiFromLinks(values) {
+    for (const value of values) {
+        if (!/doi\.org\//i.test(value))
+            continue;
+        const doi = normalizeDoi(value);
+        if (doi)
+            return doi;
+    }
+    return "";
+}
+function pubmedIdFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.hostname !== "pubmed.ncbi.nlm.nih.gov")
+            return "";
+        return normalizeSpace(parsed.pathname.replace(/^\//, "").replace(/\/$/, ""));
+    }
+    catch {
+        return "";
+    }
+}
+function pmcIdFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const match = parsed.pathname.match(/\/articles\/(PMC\d+)/i);
+        return normalizeSpace(String(match?.[1] || "")).toUpperCase();
+    }
+    catch {
+        return "";
+    }
+}
+function preprintServer(url) {
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+        if (host === "www.biorxiv.org" || host === "biorxiv.org")
+            return "biorxiv";
+        if (host === "www.medrxiv.org" || host === "medrxiv.org")
+            return "medrxiv";
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+function preprintDoiFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const match = parsed.pathname.match(/\/content\/(10\.1101\/[^?#]+?)(?:v\d+)?(?:\.full(?:\.pdf)?)?(?:$|[?#])/i);
+        return normalizeDoi(String(match?.[1] || ""));
+    }
+    catch {
+        return "";
+    }
+}
+function siteLabel(url) {
+    try {
+        const host = new URL(url).hostname.toLowerCase().replace(/^www\./, "");
+        if (host === "pubmed.ncbi.nlm.nih.gov")
+            return "pubmed";
+        if (host === "pmc.ncbi.nlm.nih.gov")
+            return "pmc";
+        if (host === "biorxiv.org")
+            return "biorxiv";
+        if (host === "medrxiv.org")
+            return "medrxiv";
+        const parts = host.split(".");
+        return parts.length >= 2 ? parts[parts.length - 2] || host : host;
+    }
+    catch {
+        return "";
+    }
+}
+function looksAcademicHost(url) {
+    try {
+        const host = new URL(url).hostname.toLowerCase().replace(/^www\./, "");
+        const knownHosts = [
+            "pubmed.ncbi.nlm.nih.gov",
+            "pmc.ncbi.nlm.nih.gov",
+            "biorxiv.org",
+            "medrxiv.org",
+            "nature.com",
+            "sciencedirect.com",
+            "springer.com",
+            "link.springer.com",
+            "onlinelibrary.wiley.com",
+            "academic.oup.com",
+            "jamanetwork.com",
+            "nejm.org",
+            "thelancet.com",
+            "cell.com",
+            "plos.org",
+            "biomedcentral.com",
+            "frontiersin.org",
+            "sagepub.com",
+            "tandfonline.com",
+            "ieeexplore.ieee.org",
+            "dl.acm.org",
+        ];
+        return knownHosts.some((item) => host === item || host.endsWith(`.${item}`));
+    }
+    catch {
+        return false;
+    }
+}
+function authorListFromPost(post) {
+    const authors = post.authors;
+    if (Array.isArray(authors))
+        return uniqueTexts(authors.map((item) => textValue(item)));
+    const author = textValue(post.author);
+    return author ? [author] : [];
+}
+function extractAcademicSignals(context, normalized) {
+    const html = String(context.active.content || "");
+    const post = objectValue(normalized.post);
+    const resolvedUrl = context.resolvedUrl || context.url;
+    const preprintDoi = preprintDoiFromUrl(resolvedUrl);
+    const hostLooksAcademic = looksAcademicHost(resolvedUrl);
+    return {
+        title: textValue(post.title) || normalizeSpace(extractMetaName(html, "citation_title")
+            || extractMetaName(html, "dc.title")
+            || extractMetaProperty(html, "og:title")
+            || extractTitleFromHtml(html)),
+        abstract: textValue(post.description) || normalizeSpace(extractMetaName(html, "citation_abstract")
+            || extractMetaName(html, "dc.description")
+            || extractMetaProperty(html, "og:description")
+            || extractMetaDescription(html)),
+        authors: uniqueTexts([
+            ...authorListFromPost(post),
+            ...allMetaNames(html, ["citation_author", "dc.contributor", "dc.creator"]),
+        ]),
+        doi: normalizeDoi(textValue(post.doi) || extractMetaName(html, "citation_doi") || preprintDoi || (hostLooksAcademic ? extractDoiFromLinks(context.active.links) : "")),
+        pmid: textValue(post.pmid) || extractMetaName(html, "citation_pmid") || pubmedIdFromUrl(resolvedUrl),
+        pmcid: textValue(post.pmcid) || normalizeSpace(extractMetaName(html, "citation_pmcid") || pmcIdFromUrl(resolvedUrl)).toUpperCase(),
+        journal: textValue(post.journal) || normalizeSpace(extractMetaName(html, "citation_journal_title")
+            || extractMetaName(html, "dc.source")
+            || extractMetaName(html, "citation_publisher")),
+        published: textValue(post.published) || normalizeSpace(extractMetaName(html, "citation_publication_date")
+            || extractMetaName(html, "citation_online_date")
+            || extractMetaName(html, "dc.date")),
+        pdfUrls: dedupeUrls([
+            textValue(post.pdf_url),
+            absolutizeUrl(extractMetaName(html, "citation_pdf_url"), resolvedUrl),
+            ...context.active.links.filter((link) => looksLikePdfUrl(link)),
+        ]),
+        fullTextUrls: dedupeUrls([
+            textValue(post.full_text_url),
+            absolutizeUrl(extractMetaName(html, "citation_fulltext_html_url"), resolvedUrl),
+            textValue(post.open_access_url),
+        ]),
+        license: textValue(post.open_access_license),
+        oaStatus: textValue(post.open_access_status),
+        publishedDoi: normalizeDoi(textValue(post.published_doi)),
+        category: textValue(post.category),
+        jatsXml: textValue(post.jats_xml),
+        site: textValue(post.site) || siteLabel(resolvedUrl),
+        canonicalUrl: textValue(post.url) || resolvedUrl,
+    };
+}
+function mergeSignals(target, source, options) {
+    target.title ||= normalizeSpace(source.title || "");
+    target.abstract ||= normalizeSpace(source.abstract || "");
+    if (target.authors.length === 0)
+        target.authors = uniqueTexts(source.authors || []);
+    target.doi ||= normalizeDoi(source.doi || "");
+    target.pmid ||= normalizeSpace(source.pmid || "");
+    target.pmcid ||= normalizeSpace(source.pmcid || "").toUpperCase();
+    target.journal ||= normalizeSpace(source.journal || "");
+    target.published ||= normalizeSpace(source.published || "");
+    target.pdfUrls = options?.linkOrder === "prepend"
+        ? dedupeUrls([...(source.pdfUrls || []), ...target.pdfUrls])
+        : dedupeUrls([...target.pdfUrls, ...(source.pdfUrls || [])]);
+    target.fullTextUrls = options?.linkOrder === "prepend"
+        ? dedupeUrls([...(source.fullTextUrls || []), ...target.fullTextUrls])
+        : dedupeUrls([...target.fullTextUrls, ...(source.fullTextUrls || [])]);
+    target.license ||= normalizeSpace(source.license || "");
+    target.oaStatus ||= normalizeSpace(source.oaStatus || "");
+    target.publishedDoi ||= normalizeDoi(source.publishedDoi || "");
+    target.category ||= normalizeSpace(source.category || "");
+    target.jatsXml ||= normalizeSpace(source.jatsXml || "");
+    target.site ||= normalizeSpace(source.site || "");
+    target.canonicalUrl ||= normalizeSpace(source.canonicalUrl || "");
+}
+async function fetchBioRxivRecord(context, server, doi) {
+    const result = await fetchProviderJson(`https://api.biorxiv.org/details/${server}/${doi}/na/json`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    const collection = Array.isArray(data.collection) ? data.collection : [];
+    const record = objectValue(collection[0]);
+    if (Object.keys(record).length === 0)
+        return null;
+    const authors = uniqueTexts(textValue(record.authors).split(";").map((item) => item.trim()));
+    const normalizedServer = server.toLowerCase();
+    const version = textValue(record.version) || "1";
+    const preprintDoi = normalizeDoi(textValue(record.doi) || doi);
+    const canonicalUrl = preprintDoi ? `https://www.${normalizedServer}.org/content/${preprintDoi}v${version}` : context.url;
+    return {
+        title: textValue(record.title),
+        abstract: normalizeSpace(textValue(record.abstract).replace(/\s+/g, " ")),
+        authors,
+        doi: preprintDoi,
+        publishedDoi: normalizeDoi(textValue(record.published)),
+        published: textValue(record.date),
+        pdfUrls: canonicalUrl ? [`${canonicalUrl}.full.pdf`] : [],
+        fullTextUrls: canonicalUrl ? [canonicalUrl] : [],
+        license: textValue(record.license),
+        category: textValue(record.category),
+        jatsXml: textValue(record.jatsxml),
+        site: normalizedServer,
+        canonicalUrl,
+    };
+}
+function europePmcQuery(signals) {
+    if (signals.doi)
+        return `DOI:${signals.doi}`;
+    if (signals.pmcid)
+        return `PMCID:${signals.pmcid}`;
+    if (signals.pmid)
+        return `EXT_ID:${signals.pmid} AND SRC:MED`;
+    return "";
+}
+function europePmcLinks(entry) {
+    const list = objectValue(entry.fullTextUrlList);
+    const items = Array.isArray(list.fullTextUrl) ? list.fullTextUrl : [];
+    const openAccessItems = items.map((item) => objectValue(item)).filter((item) => textValue(item.availabilityCode).toUpperCase() === "OA" || textValue(item.availability).toLowerCase() === "open access");
+    const urls = openAccessItems.map((item) => textValue(item.url)).filter(Boolean);
+    return {
+        pdfUrls: urls.filter((url) => looksLikePdfUrl(url) || textValue(objectValue(openAccessItems.find((item) => textValue(item.url) === url)).documentStyle).toLowerCase() === "pdf"),
+        fullTextUrls: urls.filter((url) => !looksLikePdfUrl(url) || /articles\/PMC/i.test(url)),
+    };
+}
+async function fetchEuropePmcRecord(context, signals) {
+    const query = europePmcQuery(signals);
+    if (!query)
+        return null;
+    const result = await fetchProviderJson(`https://www.ebi.ac.uk/europepmc/webservices/rest/search?query=${encodeURIComponent(query)}&format=json&pageSize=1&resultType=core`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    const resultList = objectValue(data.resultList);
+    const list = Array.isArray(resultList.result) ? resultList.result : [];
+    const entry = objectValue(list[0]);
+    if (Object.keys(entry).length === 0)
+        return null;
+    const links = europePmcLinks(entry);
+    return {
+        title: textValue(entry.title),
+        abstract: textValue(entry.abstractText),
+        authors: uniqueTexts(textValue(entry.authorString).split(/[;,]/).map((item) => item.trim())),
+        doi: normalizeDoi(textValue(entry.doi)),
+        pmid: textValue(entry.pmid),
+        pmcid: textValue(entry.pmcid).toUpperCase(),
+        journal: textValue(entry.journalTitle),
+        published: textValue(entry.firstPublicationDate) || textValue(entry.firstIndexDate),
+        pdfUrls: links.pdfUrls,
+        fullTextUrls: links.fullTextUrls,
+    };
+}
+function openAlexAuthors(data) {
+    const authorships = Array.isArray(data.authorships) ? data.authorships : [];
+    return uniqueTexts(authorships.map((item) => textValue(objectValue(objectValue(item).author).display_name)));
+}
+function openAlexLinks(data) {
+    const best = objectValue(data.best_oa_location);
+    const primary = objectValue(data.primary_location);
+    const locations = Array.isArray(data.locations) ? data.locations.slice(0, 6) : [];
+    const pdfUrls = dedupeUrls([
+        textValue(best.pdf_url),
+        textValue(primary.pdf_url),
+        ...locations.map((item) => textValue(objectValue(item).pdf_url)),
+    ]);
+    const fullTextUrls = dedupeUrls([
+        textValue(best.landing_page_url),
+        textValue(primary.landing_page_url),
+        textValue(objectValue(data.open_access).oa_url),
+        ...locations.map((item) => textValue(objectValue(item).landing_page_url)),
+    ]);
+    return { pdfUrls, fullTextUrls };
+}
+async function fetchOpenAlexRecord(context, doi) {
+    const result = await fetchProviderJson(`https://api.openalex.org/works/${encodeURIComponent(`doi:${doi}`)}`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    if (Object.keys(data).length === 0)
+        return null;
+    const openAccess = objectValue(data.open_access);
+    const links = openAlexLinks(data);
+    const best = objectValue(data.best_oa_location);
+    const primary = objectValue(data.primary_location);
+    const bestSource = objectValue(best.source);
+    const primarySource = objectValue(primary.source);
+    return {
+        title: textValue(data.title),
+        authors: openAlexAuthors(data),
+        journal: textValue(bestSource.display_name) || textValue(primarySource.display_name) || textValue(objectValue(data.primary_location).display_name),
+        published: textValue(data.publication_date),
+        license: textValue(best.license) || textValue(primary.license),
+        oaStatus: textValue(openAccess.oa_status),
+        pdfUrls: links.pdfUrls,
+        fullTextUrls: links.fullTextUrls,
+    };
+}
+function unpaywallLinks(data) {
+    const best = objectValue(data.best_oa_location);
+    const locations = arrayValue(data.oa_locations).map((item) => objectValue(item)).slice(0, 8);
+    const pdfUrls = dedupeUrls([
+        httpUrl(best.url_for_pdf),
+        ...locations.map((item) => httpUrl(item.url_for_pdf)),
+    ]);
+    const fullTextUrls = dedupeUrls([
+        httpUrl(best.url_for_landing_page),
+        httpUrl(best.url),
+        ...locations.map((item) => httpUrl(item.url_for_landing_page)),
+        ...locations.map((item) => httpUrl(item.url)),
+    ]).filter((url) => !/doi\.org\//i.test(url));
+    const license = textValue(best.license) || uniqueTexts(locations.map((item) => textValue(item.license)))[0] || "";
+    return { pdfUrls, fullTextUrls, license };
+}
+async function fetchUnpaywallRecord(context, doi) {
+    const email = unpaywallEmail();
+    if (!email)
+        return null;
+    const result = await fetchProviderJson(`https://api.unpaywall.org/v2/${encodeURIComponent(doi)}?email=${encodeURIComponent(email)}`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    if (Object.keys(data).length === 0)
+        return null;
+    const links = unpaywallLinks(data);
+    return {
+        title: textValue(data.title),
+        authors: authorNames(data.z_authors),
+        journal: textValue(data.journal_name),
+        published: textValue(data.published_date) || textValue(data.year),
+        license: links.license,
+        oaStatus: textValue(data.oa_status),
+        pdfUrls: links.pdfUrls,
+        fullTextUrls: links.fullTextUrls,
+        canonicalUrl: textValue(data.doi_url) || doiLinkUrl(doi),
+    };
+}
+function semanticScholarPaperId(signals) {
+    if (signals.doi)
+        return `DOI:${signals.doi}`;
+    if (signals.pmid)
+        return `PMID:${signals.pmid}`;
+    return "";
+}
+async function fetchSemanticScholarRecord(context, signals) {
+    const paperId = semanticScholarPaperId(signals);
+    if (!paperId)
+        return null;
+    const apiKey = semanticScholarApiKey();
+    const result = await fetchProviderJson(`https://api.semanticscholar.org/graph/v1/paper/${encodeURIComponent(paperId)}?fields=title,abstract,authors,venue,year,externalIds,openAccessPdf,isOpenAccess,journal,url`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            ...(apiKey ? { "x-api-key": apiKey } : {}),
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    if (Object.keys(data).length === 0)
+        return null;
+    const openAccessPdf = objectValue(data.openAccessPdf);
+    const externalIds = objectValue(data.externalIds);
+    const pdfUrl = httpUrl(openAccessPdf.url);
+    const journal = objectValue(data.journal);
+    return {
+        title: textValue(data.title),
+        abstract: textValue(data.abstract),
+        authors: authorNames(data.authors),
+        doi: normalizeDoi(textValue(externalIds.DOI)),
+        pmid: textValue(externalIds.PubMed),
+        journal: textValue(journal.name) || textValue(data.venue),
+        published: textValue(data.year),
+        license: textValue(openAccessPdf.license),
+        oaStatus: textValue(openAccessPdf.status).toLowerCase() || (data.isOpenAccess === true ? "open" : ""),
+        pdfUrls: pdfUrl && looksLikePdfUrl(pdfUrl) ? [pdfUrl] : [],
+        fullTextUrls: pdfUrl && !looksLikePdfUrl(pdfUrl) ? [pdfUrl] : [],
+        canonicalUrl: textValue(data.url),
+    };
+}
+function coreSearchLinks(data) {
+    const rawUrls = [];
+    collectUrlFields(data, /(download|full.?text|reader|url)$/i, rawUrls);
+    const urls = dedupeUrls(rawUrls.map((item) => httpUrl(item)).filter(Boolean)).filter((url) => !/^https?:\/\/api\.core\.ac\.uk\//i.test(url) && !/doi\.org\//i.test(url));
+    return {
+        pdfUrls: urls.filter((url) => looksLikePdfUrl(url)),
+        fullTextUrls: urls.filter((url) => !looksLikePdfUrl(url)),
+    };
+}
+async function fetchCoreSearchRecord(context, doi) {
+    const apiKey = coreApiKey();
+    if (!apiKey)
+        return null;
+    const query = encodeURIComponent(`doi:"${doi}"`);
+    const result = await fetchProviderJson(`https://api.core.ac.uk/v3/search/works?q=${query}&limit=3&offset=0&sort=relevance`, context.timeoutMs, {
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            authorization: `Bearer ${apiKey}`,
+            "user-agent": "Mozilla/5.0",
+        },
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    const results = arrayValue(data.results).map((item) => objectValue(item));
+    const entry = results.find((item) => normalizeDoi(textValue(item.doi)) === doi) || results[0] || null;
+    if (!entry)
+        return null;
+    const links = coreSearchLinks(entry);
+    const journals = uniqueTexts(arrayValue(entry.journals).map((item) => textValue(objectValue(item).title)));
+    const abstract = textValue(entry.abstract) || textValue(entry.description);
+    const year = textValue(entry.yearPublished);
+    return {
+        title: textValue(entry.title),
+        abstract,
+        authors: authorNames(entry.authors),
+        doi: normalizeDoi(textValue(entry.doi)),
+        journal: journals[0] || textValue(entry.publisher),
+        published: textValue(entry.publishedDate) || year || textValue(entry.depositedDate),
+        pdfUrls: links.pdfUrls,
+        fullTextUrls: links.fullTextUrls,
+        site: "core",
+        canonicalUrl: textValue(entry.id) ? `https://core.ac.uk/works/${textValue(entry.id)}` : "",
+    };
+}
+async function fetchCoreDiscoverRecord(context, doi) {
+    const result = await fetchProviderJson("https://api.core.ac.uk/v3/discover", context.timeoutMs, {
+        method: "POST",
+        headers: {
+            accept: "application/json,text/plain,*/*",
+            "content-type": "application/json",
+            "user-agent": "Mozilla/5.0",
+        },
+        body: JSON.stringify({ doi }),
+    }, {
+        mode: "relay",
+        sourceUrl: context.url,
+    });
+    if (!result.ok)
+        return null;
+    const data = objectValue(result.data);
+    if (Object.keys(data).length === 0)
+        return null;
+    const links = coreSearchLinks(data);
+    if (links.pdfUrls.length === 0 && links.fullTextUrls.length === 0)
+        return null;
+    return {
+        title: "",
+        abstract: "",
+        authors: [],
+        doi,
+        journal: "",
+        published: "",
+        pdfUrls: links.pdfUrls,
+        fullTextUrls: links.fullTextUrls,
+        site: "core",
+        canonicalUrl: "",
+    };
+}
+async function fetchCoreRecord(context, doi) {
+    const searchRecord = await fetchCoreSearchRecord(context, doi);
+    const discoverRecord = await fetchCoreDiscoverRecord(context, doi);
+    if (!searchRecord && !discoverRecord)
+        return null;
+    const merged = {
+        title: "",
+        abstract: "",
+        authors: [],
+        doi: "",
+        journal: "",
+        published: "",
+        pdfUrls: [],
+        fullTextUrls: [],
+        site: "core",
+        canonicalUrl: "",
+    };
+    if (searchRecord)
+        mergeSignals(merged, searchRecord, { linkOrder: "prepend" });
+    if (discoverRecord)
+        mergeSignals(merged, discoverRecord);
+    return merged;
+}
+function hasPaperSignals(signals) {
+    return Boolean(signals.doi
+        || signals.pmid
+        || signals.pmcid
+        || signals.authors.length > 0
+        || signals.journal
+        || signals.pdfUrls.length > 0
+        || signals.fullTextUrls.length > 0);
+}
+function composePaperText(currentText, signals, bestPdfUrl, bestFullTextUrl) {
+    const narrative = currentText.length > 600
+        ? currentText
+        : signals.abstract || currentText;
+    const metadata = [
+        signals.authors.length > 0 ? `Authors: ${signals.authors.join(", ")}` : "",
+        signals.journal ? `Journal: ${signals.journal}` : "",
+        signals.published ? `Published: ${signals.published}` : "",
+        signals.doi ? `DOI: ${signals.doi}` : "",
+        signals.publishedDoi ? `Published DOI: ${signals.publishedDoi}` : "",
+        signals.pmid ? `PMID: ${signals.pmid}` : "",
+        signals.pmcid ? `PMCID: ${signals.pmcid}` : "",
+        signals.oaStatus ? `Open access: ${signals.oaStatus}` : "",
+        signals.license ? `License: ${signals.license}` : "",
+        signals.category ? `Category: ${signals.category}` : "",
+        bestPdfUrl ? `PDF: ${bestPdfUrl}` : "",
+        bestFullTextUrl ? `Full text: ${bestFullTextUrl}` : "",
+        signals.jatsXml ? `JATS XML: ${signals.jatsXml}` : "",
+    ].filter(Boolean).join("\n");
+    const blocks = [normalizeSpace(narrative) ? narrative.trim() : "", metadata].filter(Boolean);
+    return Array.from(new Set(blocks)).join("\n\n").slice(0, 50000);
+}
+export async function maybeUseAcademicFallback(context, normalized) {
+    if (!academicFallbackEnabled())
+        return { normalized, retrievalMethods: [] };
+    const post = objectValue(normalized.post);
+    const resolvedUrl = context.resolvedUrl || context.url;
+    const signals = extractAcademicSignals(context, normalized);
+    const retrievalMethods = [];
+    const server = preprintServer(resolvedUrl);
+    if (server && biorxivApiEnabled()) {
+        const apiDoi = signals.doi || preprintDoiFromUrl(resolvedUrl);
+        if (apiDoi) {
+            const preprint = await fetchBioRxivRecord(context, server, apiDoi);
+            if (preprint) {
+                mergeSignals(signals, preprint);
+                retrievalMethods.push("academic_biorxiv_api");
+            }
+        }
+    }
+    if (!hasPaperSignals(signals) && !String(textValue(post.kind)).startsWith("paper_")) {
+        return { normalized, retrievalMethods: [] };
+    }
+    if (europePmcEnabled() && (signals.doi || signals.pmid || signals.pmcid)) {
+        const europePmc = await fetchEuropePmcRecord(context, signals);
+        if (europePmc) {
+            mergeSignals(signals, europePmc);
+            retrievalMethods.push("academic_europepmc");
+        }
+    }
+    if (openAlexEnabled() && signals.doi) {
+        const openAlex = await fetchOpenAlexRecord(context, signals.doi);
+        if (openAlex) {
+            mergeSignals(signals, openAlex);
+            signals.pdfUrls = dedupeUrls([...(openAlex.pdfUrls || []), ...signals.pdfUrls]);
+            signals.fullTextUrls = dedupeUrls([...(openAlex.fullTextUrls || []), ...signals.fullTextUrls]);
+            retrievalMethods.push("academic_openalex");
+        }
+    }
+    const title = signals.title || textValue(post.title);
+    const description = signals.abstract || textValue(post.description);
+    const doiUrl = doiLinkUrl(signals.doi);
+    const pubmedUrl = signals.pmid ? `https://pubmed.ncbi.nlm.nih.gov/${signals.pmid}/` : "";
+    const pmcUrl = signals.pmcid ? `https://pmc.ncbi.nlm.nih.gov/articles/${signals.pmcid}/` : "";
+    const bestPdfUrl = signals.pdfUrls[0] || "";
+    const bestFullTextUrl = signals.fullTextUrls.find((url) => url !== bestPdfUrl) || pmcUrl || doiUrl || "";
+    const kind = server ? "paper_preprint" : String(textValue(post.kind)).startsWith("paper_") ? textValue(post.kind) : "paper_article";
+    const status = title && (description || bestPdfUrl || bestFullTextUrl || signals.doi || signals.pmid || signals.pmcid)
+        ? "ok"
+        : textValue(post.status) || "reference_only";
+    const text = composePaperText(String(post.text || "").trim(), signals, bestPdfUrl, bestFullTextUrl);
+    const outboundLinks = dedupeUrls([
+        ...normalized.outbound_links,
+        signals.canonicalUrl,
+        doiUrl,
+        pubmedUrl,
+        pmcUrl,
+        ...signals.pdfUrls,
+        ...signals.fullTextUrls,
+        signals.jatsXml,
+    ]);
+    const authors = signals.authors.length > 0 ? signals.authors : authorListFromPost(post);
+    const nextPost = {
+        ...post,
+        url: textValue(post.url) || signals.canonicalUrl || context.url,
+        title,
+        description,
+        text,
+        ...(authors.length > 0 ? { authors } : {}),
+        ...(signals.journal ? { journal: signals.journal } : {}),
+        ...(signals.published ? { published: signals.published } : {}),
+        ...(signals.doi ? { doi: signals.doi } : {}),
+        ...(signals.pmid ? { pmid: signals.pmid } : {}),
+        ...(signals.pmcid ? { pmcid: signals.pmcid } : {}),
+        ...(signals.publishedDoi ? { published_doi: signals.publishedDoi } : {}),
+        ...(signals.oaStatus ? { open_access_status: signals.oaStatus } : {}),
+        ...(signals.license ? { open_access_license: signals.license } : {}),
+        ...(bestPdfUrl ? { pdf_url: bestPdfUrl } : {}),
+        ...(bestFullTextUrl ? { full_text_url: bestFullTextUrl } : {}),
+        ...(signals.category ? { category: signals.category } : {}),
+        ...(signals.jatsXml ? { jats_xml: signals.jatsXml } : {}),
+        ...(signals.site ? { site: signals.site } : {}),
+        kind,
+        status,
+    };
+    const currentPostJson = JSON.stringify(normalized.post || null);
+    const nextPostJson = JSON.stringify(nextPost);
+    const currentLinksJson = JSON.stringify(normalized.outbound_links);
+    const nextLinksJson = JSON.stringify(outboundLinks);
+    const improved = currentPostJson !== nextPostJson || currentLinksJson !== nextLinksJson;
+    if (!improved)
+        return { normalized, retrievalMethods: [] };
+    return {
+        normalized: {
+            ...normalized,
+            post: nextPost,
+            outbound_links: outboundLinks,
+            partial: !(title && (description || bestPdfUrl || bestFullTextUrl || signals.doi || signals.pmid || signals.pmcid)),
+        },
+        retrievalMethods: Array.from(new Set(retrievalMethods)),
+    };
+}
+//# sourceMappingURL=academic-fallback.js.map