@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/literature/sources/arxiv.js

@@ -1,78 +1,135 @@
+import { presentAt } from "../../lib/present.js";
+import { collapseWhitespace as collapseText, isAllDigits, isAllHex } from "../../lib/text.js";
 import { requestText } from "./http.js";
 const BASE_URL = "https://export.arxiv.org/api/query";
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- an Atom feed wraps text in CDATA sections; this keeps the text of each nearest opener/closer pair.
 const stripCdata = (value) => value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1");
-const decodeXmlEntities = (value) => value
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&apos;/g, "'")
-    .replace(/&#x([0-9a-fA-F]+);/g, (_, hexadecimal) => String.fromCodePoint(parseInt(hexadecimal, 16)))
-    .replace(/&#(\d+);/g, (_, decimal) => String.fromCodePoint(parseInt(decimal, 10)))
-    .replace(/&amp;/g, "&");
-const collapseWhitespace = (value) => decodeXmlEntities(stripCdata(value)).replace(/\s+/g, " ").trim();
-function extractEntries(xml) {
-    const expression = /<entry\b[^>]*>([\s\S]*?)<\/entry>/g;
-    const entries = [];
-    let match;
-    while ((match = expression.exec(xml)) !== null)
-        entries.push(match[1]);
-    return entries;
+const NAMED_XML_ENTITIES = new Map([
+    ["lt", "<"],
+    ["gt", ">"],
+    ["quot", '"'],
+    ["apos", "'"],
+    ["amp", "&"],
+]);
+function decodeEntity(body) {
+    const named = NAMED_XML_ENTITIES.get(body);
+    if (named !== undefined)
+        return named;
+    if (body.startsWith("#x")) {
+        const hexadecimal = body.slice(2);
+        return hexadecimal.length > 0 && isAllHex(hexadecimal) ? String.fromCodePoint(parseInt(hexadecimal, 16)) : undefined;
+    }
+    if (body.startsWith("#")) {
+        const decimal = body.slice(1);
+        return decimal.length > 0 && isAllDigits(decimal) ? String.fromCodePoint(parseInt(decimal, 10)) : undefined;
+    }
+    return undefined;
 }
-function firstMatch(entry, tag) {
-    return entry.match(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`))?.[1];
+/**
+ * Decode the XML entities the feed emits, in one pass.
+ *
+ * A single pass cannot re-decode its own output: `&amp;lt;` yields `&lt;`, never `<`.
+ * A body that names no entity — or a numeric body that is not well-formed — stays literal.
+ */
+function decodeXmlEntities(value) {
+    let out = "";
+    for (let i = 0; i < value.length;) {
+        if (value.charAt(i) !== "&") {
+            out += value.charAt(i);
+            i++;
+            continue;
+        }
+        const semicolon = value.indexOf(";", i);
+        const decoded = semicolon < 0 ? undefined : decodeEntity(value.slice(i + 1, semicolon));
+        if (decoded === undefined) {
+            out += "&";
+            i++;
+            continue;
+        }
+        out += decoded;
+        i = semicolon + 1;
+    }
+    return out;
 }
+const collapseWhitespace = (value) => collapseText(decodeXmlEntities(stripCdata(value)));
 function allMatches(entry, tag) {
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- an Atom tag's content is `<tag …>` up to the nearest `</tag>`; the expression is built per tag name, and a tag name is not data.
     const expression = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "g");
     const values = [];
     let match;
     while ((match = expression.exec(entry)) !== null)
-        values.push(match[1]);
+        values.push(presentAt(match, 1, `the captured ${tag}`));
     return values;
 }
-function linkAttribute(entry, predicate) {
-    const expression = /<link\b([^>]*)\/>/g;
+function firstMatch(entry, tag) {
+    return allMatches(entry, tag)[0];
+}
+function attributeValue(attributes, name) {
+    const marker = `${name}="`;
+    const start = attributes.indexOf(marker);
+    if (start < 0)
+        return undefined;
+    const valueStart = start + marker.length;
+    const end = attributes.indexOf('"', valueStart);
+    return end > valueStart ? attributes.slice(valueStart, end) : undefined;
+}
+function selfClosingAttributes(entry, tag) {
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- a self-closing Atom tag carries its attributes in the tag itself: `<tag … />`; the expression is built per tag name.
+    const expression = new RegExp(`<${tag}\\b([^>]*)/>`, "g");
+    const values = [];
     let match;
-    while ((match = expression.exec(entry)) !== null) {
-        const attributes = match[1];
+    while ((match = expression.exec(entry)) !== null)
+        values.push(presentAt(match, 1, `the attributes of ${tag}`));
+    return values;
+}
+function linkAttribute(entry, predicate) {
+    for (const attributes of selfClosingAttributes(entry, "link")) {
         if (predicate(attributes))
-            return attributes.match(/href="([^"]+)"/)?.[1];
+            return attributeValue(attributes, "href");
     }
     return undefined;
 }
 function categoryTerms(entry) {
-    const expression = /<category\b([^>]*)\/>/g;
     const terms = [];
-    let match;
-    while ((match = expression.exec(entry)) !== null) {
-        const term = match[1].match(/term="([^"]+)"/)?.[1];
+    for (const attributes of selfClosingAttributes(entry, "category")) {
+        const term = attributeValue(attributes, "term");
         if (term !== undefined)
             terms.push(term);
     }
     return terms;
 }
+function afterMarker(text, marker) {
+    const start = text.indexOf(marker);
+    if (start < 0)
+        return undefined;
+    const rest = text.slice(start + marker.length);
+    return rest.length > 0 ? rest : undefined;
+}
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the Atom envelope probe: a `<feed` element opens the document; the word boundary keeps a longer element name from passing.
+const ATOM_FEED_ELEMENT = /<feed\b/;
 export function parseArxivAtom(xml) {
-    return extractEntries(xml).flatMap((entry) => {
+    return allMatches(xml, "entry").flatMap((entry) => {
         const rawId = firstMatch(entry, "id");
         const title = firstMatch(entry, "title");
         if (rawId === undefined || title === undefined)
             return [];
-        const idMatch = rawId.match(/abs\/(.+)$/);
+        const idMatch = afterMarker(rawId, "abs/");
         const authors = allMatches(entry, "author")
             .map((author) => firstMatch(author, "name"))
             .filter((name) => name !== undefined)
             .map(collapseWhitespace);
-        const htmlUrl = linkAttribute(entry, (attributes) => /rel="alternate"/.test(attributes) && /type="text\/html"/.test(attributes));
-        const pdfUrl = linkAttribute(entry, (attributes) => /title="pdf"/.test(attributes));
+        const htmlUrl = linkAttribute(entry, (attributes) => attributes.includes('rel="alternate"') && attributes.includes('type="text/html"'));
+        const pdfUrl = linkAttribute(entry, (attributes) => attributes.includes('title="pdf"'));
         return [
             {
-                id: idMatch?.[1] ?? collapseWhitespace(rawId),
+                id: idMatch ?? collapseWhitespace(rawId),
                 title: collapseWhitespace(title),
                 abstract: collapseWhitespace(firstMatch(entry, "summary") ?? ""),
                 authors,
                 published: collapseWhitespace(firstMatch(entry, "published") ?? ""),
                 categories: categoryTerms(entry),
                 url: htmlUrl ?? collapseWhitespace(rawId),
-                ...(pdfUrl === undefined ? {} : { pdfUrl }),
+                pdfUrl,
             },
         ];
     });
@@ -82,7 +139,7 @@ export function createArxivSource(options = {}) {
         const result = await requestText(`${BASE_URL}?${params}`, options, signal);
         if (result.status !== "ok")
             return result;
-        if (!/<feed\b/.test(result.value))
+        if (!ATOM_FEED_ELEMENT.test(result.value))
             return { status: "unavailable", detail: "response schema mismatch: missing Atom feed" };
         return { status: "ok", value: parseArxivAtom(result.value) };
     }

package/dist/literature/sources/http.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export interface SourceHttpOptions {
+export type SourceHttpOptions = {
     readonly fetch?: typeof globalThis.fetch;
     /**
      * Admission gate wrapped around each network attempt — a rate limiter, a
@@ -13,7 +13,7 @@ export interface SourceHttpOptions {
     /** Ceiling on any single retry wait, including one a server asks for via `Retry-After`. */
     readonly maxRetryDelayMs?: number;
     readonly sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
-}
+};
 export type SourceHttpResult<T> = {
     readonly status: "ok";
     readonly value: T;

package/dist/literature/sources/http.js

@@ -1,20 +1,21 @@
+import { errorOf, errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
+import { setTimeout as timerSleep } from "node:timers/promises";
 const RETRYABLE_STATUSES = new Set([429, 503]);
 function cancellationReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+    return errorOf(signal.reason) ?? new DOMException("The operation was aborted", "AbortError");
 }
 async function delay(ms, signal) {
-    if (signal?.aborted)
+    if (signal === undefined) {
+        await timerSleep(ms);
+        return;
+    }
+    if (signal.aborted)
+        throw cancellationReason(signal);
+    // The node wait's abort rejection is a fresh AbortError instead of the signal's
+    // reason under the Bun test runtime, so the catch restores this contract's reason.
+    await timerSleep(ms, undefined, { signal }).catch(() => {
         throw cancellationReason(signal);
-    await new Promise((resolve, reject) => {
-        const onAbort = () => {
-            clearTimeout(timeout);
-            reject(cancellationReason(signal));
-        };
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
 function retryAfterMilliseconds(response) {
@@ -66,7 +67,7 @@ async function request(url, options, signal, init) {
                 await sleep(backoff(attempt), signal);
                 continue;
             }
-            return { status: "unavailable", detail: error instanceof Error ? error.message : String(error) };
+            return { status: "unavailable", detail: errorMessageOf(error) ?? textOf(error) };
         }
     }
 }
@@ -81,7 +82,7 @@ export async function requestJson(url, schema, options, signal, init = {}) {
         return { status: "ok", value: parsed.data };
     }
     catch (error) {
-        return { status: "unavailable", detail: `invalid JSON response: ${error instanceof Error ? error.message : String(error)}` };
+        return { status: "unavailable", detail: `invalid JSON response: ${errorMessageOf(error) ?? textOf(error)}` };
     }
 }
 export async function requestText(url, options, signal, init = {}) {
@@ -92,6 +93,6 @@ export async function requestText(url, options, signal, init = {}) {
         return { status: "ok", value: await response.value.text() };
     }
     catch (error) {
-        return { status: "unavailable", detail: `invalid text response: ${error instanceof Error ? error.message : String(error)}` };
+        return { status: "unavailable", detail: `invalid text response: ${errorMessageOf(error) ?? textOf(error)}` };
     }
 }

package/dist/literature/sources/pubmed.d.ts

@@ -1,33 +1,33 @@
 import { type SourceHttpOptions, type SourceHttpResult } from "./http.js";
 export declare const NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils";
 export declare const NCBI_IDCONV = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0";
-export interface PubmedSourceOptions extends SourceHttpOptions {
+export type PubmedSourceOptions = SourceHttpOptions & {
     readonly apiKey?: string;
-}
-export interface PubmedSearchOptions {
+};
+export type PubmedSearchOptions = {
     readonly maxResults?: number;
     readonly sort?: "relevance" | "date";
     readonly dateRange?: {
         readonly from: string;
         readonly to: string;
     };
-}
-export interface PubmedCitationFields {
+};
+export type PubmedCitationFields = {
     readonly venue?: string;
     readonly year?: string | number;
     readonly volume?: string;
     readonly firstPage?: string;
     readonly firstAuthor?: string;
     readonly key: string;
-}
-export interface PubMedSummary {
+};
+export type PubMedSummary = {
     pmid: string;
     title: string;
     journal: string;
     year: string;
     authors: string;
-}
-export interface ArticleDetail {
+};
+export type ArticleDetail = {
     pmid: string;
     title: string;
     abstract: string;
@@ -37,16 +37,16 @@ export interface ArticleDetail {
     doi: string;
     meshTerms: string[];
     pmcId: string | null;
-}
-export interface ArticleSection {
+};
+export type ArticleSection = {
     heading: string;
     text: string;
-}
-export interface FullTextResult {
+};
+export type FullTextResult = {
     fullText: string;
     sections: ArticleSection[];
-}
-export interface PubmedSource {
+};
+export type PubmedSource = {
     search(query: string, options?: PubmedSearchOptions, signal?: AbortSignal): Promise<SourceHttpResult<{
         totalFound: number;
         results: PubMedSummary[];
@@ -59,7 +59,7 @@ export interface PubmedSource {
         notFound: string[];
     }>>;
     fetchFullText(pmcId: string, signal?: AbortSignal): Promise<SourceHttpResult<FullTextResult | null>>;
-}
+};
 export declare function ncbiUrl(apiKey: string | undefined, base: string, params: Record<string, string | number | undefined>): string;
 export declare function parseEsummary(xml: string): PubMedSummary[];
 export declare function parseEfetch(xml: string): ArticleDetail[];

package/dist/literature/sources/pubmed.js

@@ -1,6 +1,10 @@
+import { textOf } from "../../lib/unknown-text.js";
 import { XMLParser } from "fast-xml-parser";
 import { z } from "zod";
 import { requestJson, requestText } from "./http.js";
+import { isAllDigits, splitLines } from "../../lib/text.js";
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the PubmedArticleSet envelope probe; the word boundary keeps a longer element name from passing.
+const PUBMED_ARTICLE_SET_ELEMENT = /<PubmedArticleSet\b/;
 export const NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils";
 export const NCBI_IDCONV = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0";
 const EsearchResponseSchema = z.object({
@@ -29,33 +33,63 @@ const xmlParser = new XMLParser({
     // then crashes the year extraction in `parseEsummary`.
     parseTagValue: false,
 });
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/** The string the record holds at `key`, or `undefined` when the key is absent or holds a non-string. The XML parser is configured with `parseTagValue: false`, so every text node arrives as a string. */
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function parseXmlRecord(xml) {
+    const parsed = xmlParser.parse(xml);
+    return isRecord(parsed) ? parsed : undefined;
+}
+function childRecord(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const child = value[key];
+    return isRecord(child) ? child : undefined;
+}
+function recordList(value) {
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value))
+        return value.filter(isRecord);
+    return isRecord(value) ? [value] : [];
+}
+function isDocSumItem(value) {
+    return typeof value === "object" && value !== null;
+}
+function itemOf(value) {
+    if (value === undefined)
+        return [];
+    return (Array.isArray(value) ? value : [value]).filter(isDocSumItem);
+}
 function getItemValue(items, name) {
-    if (items === undefined)
-        return "";
-    const item = (Array.isArray(items) ? items : [items]).find((candidate) => candidate["@_Name"] === name);
+    const item = itemOf(items).find((candidate) => candidate["@_Name"] === name);
     return item?.["#text"] ?? "";
 }
 function getAuthorsFromDocSum(items) {
-    if (items === undefined)
-        return "";
-    const authorList = (Array.isArray(items) ? items : [items]).find((item) => item["@_Name"] === "AuthorList");
+    const authorList = itemOf(items).find((item) => item["@_Name"] === "AuthorList");
     if (authorList?.Item === undefined)
         return "";
-    const names = (Array.isArray(authorList.Item) ? authorList.Item : [authorList.Item]).map((author) => author["#text"] ?? "").filter(Boolean);
+    const names = itemOf(authorList.Item)
+        .map((author) => author["#text"] ?? "")
+        .filter(Boolean);
     if (names.length <= 3)
         return names.join(", ");
-    return `${names[0]} et al.`;
+    return `${String(names[0])} et al.`;
 }
 export function parseEsummary(xml) {
-    const parsed = xmlParser.parse(xml);
-    const docSums = (parsed?.eSummaryResult ?? parsed)?.DocSum;
+    const parsed = parseXmlRecord(xml);
+    const docSums = (childRecord(parsed, "eSummaryResult") ?? parsed)?.DocSum;
     if (docSums === undefined)
         return [];
-    const documents = Array.isArray(docSums) ? docSums : [docSums];
-    return documents.map((document) => {
+    return recordList(docSums).map((document) => {
         const publicationDate = getItemValue(document.Item, "PubDate");
         return {
-            pmid: String(document.Id ?? ""),
+            pmid: textOf(document.Id ?? ""),
             title: getItemValue(document.Item, "Title"),
             journal: getItemValue(document.Item, "FullJournalName") || getItemValue(document.Item, "Source"),
             year: publicationDate.slice(0, 4),
@@ -64,57 +98,56 @@ export function parseEsummary(xml) {
     });
 }
 export function parseEfetch(xml) {
-    const articleSet = xmlParser.parse(xml)?.PubmedArticleSet;
+    const articleSet = childRecord(parseXmlRecord(xml), "PubmedArticleSet");
     if (articleSet === undefined)
         return [];
-    const entries = Array.isArray(articleSet.PubmedArticle)
-        ? articleSet.PubmedArticle
-        : articleSet.PubmedArticle === undefined
-            ? []
-            : [articleSet.PubmedArticle];
+    const entries = recordList(articleSet.PubmedArticle);
     return entries.map((entry) => {
-        const article = entry;
-        const citation = article.MedlineCitation;
-        const articleData = citation?.Article;
+        const citation = childRecord(entry, "MedlineCitation");
+        const articleData = childRecord(citation, "Article");
         const pmidValue = citation?.PMID;
-        const pmid = typeof pmidValue === "object" && pmidValue !== null ? String(pmidValue["#text"] ?? "") : String(pmidValue ?? "");
-        const abstractValue = articleData?.Abstract?.AbstractText;
+        const pmid = isRecord(pmidValue) ? textOf(pmidValue["#text"] ?? "") : textOf(pmidValue ?? "");
+        const abstractValue = childRecord(articleData, "Abstract")?.AbstractText;
         const abstract = (abstractValue === undefined ? [] : Array.isArray(abstractValue) ? abstractValue : [abstractValue])
             .map((value) => {
             if (typeof value === "string")
                 return value;
-            if (typeof value !== "object" || value === null)
+            if (!isRecord(value))
                 return String(value);
-            const object = value;
-            const text = String(object["#text"] ?? "");
-            return object["@_Label"] === undefined ? text : `${String(object["@_Label"])}: ${text}`;
+            const text = textOf(value["#text"] ?? "");
+            return value["@_Label"] === undefined ? text : `${textOf(value["@_Label"])}: ${text}`;
         })
             .join("\n\n");
-        const authorValue = articleData?.AuthorList?.Author;
-        const authors = (authorValue === undefined ? [] : Array.isArray(authorValue) ? authorValue : [authorValue]).map((author) => author.CollectiveName ?? [author.ForeName ?? author.Initials, author.LastName].filter(Boolean).join(" "));
-        const journalData = articleData?.Journal;
-        const publicationDate = journalData?.JournalIssue?.PubDate;
+        const authors = recordList(childRecord(articleData, "AuthorList")?.Author).map((author) => {
+            const collectiveName = stringField(author, "CollectiveName");
+            if (collectiveName !== undefined)
+                return collectiveName;
+            return [stringField(author, "ForeName") ?? stringField(author, "Initials"), stringField(author, "LastName")].filter(Boolean).join(" ");
+        });
+        const journalData = childRecord(articleData, "Journal");
+        const publicationDate = childRecord(childRecord(journalData, "JournalIssue"), "PubDate");
         let doi = "";
-        const articleIds = article.PubmedData?.ArticleIdList?.ArticleId;
-        for (const id of articleIds === undefined ? [] : Array.isArray(articleIds) ? articleIds : [articleIds]) {
-            if (typeof id === "object" && id !== null && id["@_IdType"] === "doi") {
-                doi = String(id["#text"] ?? "");
+        const articleIds = childRecord(childRecord(childRecord(entry, "PubmedData"), "ArticleIdList"), "ArticleId");
+        for (const id of recordList(articleIds)) {
+            if (stringField(id, "@_IdType") === "doi") {
+                doi = stringField(id, "#text") ?? "";
             }
         }
-        const meshValue = citation?.MeshHeadingList?.MeshHeading;
-        const meshTerms = (meshValue === undefined ? [] : Array.isArray(meshValue) ? meshValue : [meshValue])
+        const meshTerms = recordList(childRecord(citation, "MeshHeadingList")?.MeshHeading)
             .map((heading) => {
             const descriptor = heading.DescriptorName;
-            return typeof descriptor === "string" ? descriptor : (descriptor?.["#text"] ?? "");
+            if (typeof descriptor === "string")
+                return descriptor;
+            return isRecord(descriptor) ? textOf(descriptor["#text"] ?? "") : "";
         })
             .filter(Boolean);
         return {
             pmid,
-            title: String(articleData?.ArticleTitle ?? ""),
+            title: textOf(articleData?.ArticleTitle ?? ""),
             abstract,
             authors,
-            journal: String(journalData?.Title ?? journalData?.ISOAbbreviation ?? ""),
-            year: String(publicationDate?.Year ?? ""),
+            journal: textOf(journalData?.Title ?? journalData?.ISOAbbreviation ?? ""),
+            year: textOf(publicationDate?.Year ?? ""),
             doi,
             meshTerms,
             pmcId: null,
@@ -123,23 +156,24 @@ export function parseEfetch(xml) {
 }
 export function parseIdConvResponse(data) {
     const result = new Map();
-    const records = data?.records ?? [];
-    for (const record of records)
+    const parsed = IdConvResponseSchema.safeParse(data);
+    for (const record of parsed.success ? (parsed.data.records ?? []) : []) {
         if (record.pmid !== undefined && record.pmcid !== undefined)
             result.set(record.pmid, record.pmcid);
+    }
     return result;
 }
 function flattenTextContent(node) {
     if (typeof node === "string" || typeof node === "number")
         return String(node);
-    if (node === null || typeof node !== "object")
+    if (!isRecord(node))
         return "";
     return Object.entries(node)
         .flatMap(([key, value]) => {
         if (key.startsWith("@_") || key === "fig" || key === "table-wrap" || key === "supplementary-material")
             return [];
         if (key === "#text")
-            return [String(value)];
+            return [textOf(value)];
         return Array.isArray(value) ? value.map(flattenTextContent) : [flattenTextContent(value)];
     })
         .filter(Boolean)
@@ -155,23 +189,22 @@ function extractParagraphs(container) {
         .join("\n\n");
 }
 function extractSection(section, output) {
-    if (section === null || typeof section !== "object")
+    if (!isRecord(section))
         return;
-    const object = section;
-    const text = extractParagraphs(object);
+    const text = extractParagraphs(section);
     if (text)
-        output.push({ heading: typeof object.title === "string" ? object.title : "", text });
-    const nested = object.sec;
+        output.push({ heading: typeof section.title === "string" ? section.title : "", text });
+    const nested = section.sec;
     for (const child of nested === undefined ? [] : Array.isArray(nested) ? nested : [nested])
         extractSection(child, output);
 }
 export function parsePmcFullText(xml) {
-    const article = xmlParser.parse(xml)?.["pmc-articleset"]?.article;
-    const body = article?.body;
+    const article = childRecord(parseXmlRecord(xml), "pmc-articleset")?.article;
+    const body = childRecord(article, "body");
     if (body === undefined)
         return null;
     const sections = [];
-    for (const section of body.sec === undefined ? [] : Array.isArray(body.sec) ? body.sec : [body.sec])
+    for (const section of recordList(body.sec))
         extractSection(section, sections);
     if (sections.length === 0) {
         const text = extractParagraphs(body);
@@ -213,7 +246,7 @@ export function createPubmedSource(options = {}) {
         const result = await requestText(url(`${NCBI_BASE}/efetch.fcgi`, { db: "pubmed", id: pmids.join(","), rettype: "xml", retmode: "xml" }), options, signal);
         if (result.status !== "ok")
             return result;
-        if (!/<PubmedArticleSet\b/.test(result.value))
+        if (!PUBMED_ARTICLE_SET_ELEMENT.test(result.value))
             return { status: "unavailable", detail: "response schema mismatch: missing PubmedArticleSet" };
         return { status: "ok", value: parseEfetch(result.value) };
     }
@@ -238,12 +271,9 @@ export function createPubmedSource(options = {}) {
             const result = await requestText(url(`${NCBI_BASE}/ecitmatch.cgi`, { db: "pubmed", rettype: "xml", bdata }), options, signal);
             if (result.status !== "ok")
                 return result;
-            const pmids = result.value
-                .trim()
-                .split(/\r?\n/)
-                .flatMap((line) => {
+            const pmids = splitLines(result.value.trim()).flatMap((line) => {
                 const value = line.split("|").at(-1)?.trim();
-                return value !== undefined && /^\d+$/.test(value) ? [value] : [];
+                return value !== undefined && value.length > 0 && isAllDigits(value) ? [value] : [];
             });
             return { status: "ok", value: pmids };
         },
@@ -264,7 +294,12 @@ export function createPubmedSource(options = {}) {
             return { status: "ok", value: { articles: articlesResult.value, notFound: pmids.filter((pmid) => !found.has(pmid)) } };
         },
         async fetchFullText(pmcId, signal) {
-            const result = await requestText(url(`${NCBI_BASE}/efetch.fcgi`, { db: "pmc", id: pmcId.replace(/^PMC/i, ""), rettype: "xml", retmode: "xml" }), options, signal);
+            const result = await requestText(url(`${NCBI_BASE}/efetch.fcgi`, {
+                db: "pmc",
+                id: pmcId.slice(0, 3).toLowerCase() === "pmc" ? pmcId.slice(3) : pmcId,
+                rettype: "xml",
+                retmode: "xml",
+            }), options, signal);
             return result.status === "ok" ? { status: "ok", value: parsePmcFullText(result.value) } : result;
         },
     };

package/dist/literature/sources/semantic-scholar.d.ts

@@ -33,7 +33,7 @@ export declare const SearchResponseSchema: z.ZodObject<{
         externalIds: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
     }, z.core.$loose>>>;
 }, z.core.$strip>;
-export interface SemanticScholarPaper {
+export type SemanticScholarPaper = {
     id: string;
     title?: string;
     abstract?: string;
@@ -43,16 +43,16 @@ export interface SemanticScholarPaper {
     url?: string;
     authors: string[];
     externalIds?: Record<string, string>;
-}
-export interface SemanticScholarSearchPaper extends SemanticScholarPaper {
+};
+export type SemanticScholarSearchPaper = SemanticScholarPaper & {
     title: string;
-}
-export interface SemanticScholarSourceOptions extends SourceHttpOptions {
+};
+export type SemanticScholarSourceOptions = SourceHttpOptions & {
     readonly apiKey?: string;
-}
-export interface SemanticScholarSource {
+};
+export type SemanticScholarSource = {
     search(query: string, limit: number, signal?: AbortSignal): Promise<SourceHttpResult<SemanticScholarSearchPaper[]>>;
     lookupIdentifier(identifier: string, signal?: AbortSignal): Promise<SourceHttpResult<SemanticScholarPaper>>;
-}
+};
 export declare function parseSemanticScholarResponse(raw: unknown): SemanticScholarSearchPaper[];
 export declare function createSemanticScholarSource(options?: SemanticScholarSourceOptions): SemanticScholarSource;