@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/citations/match.d.ts

@@ -1,10 +1,10 @@
 import type { CitationCandidateCluster, CitationInput, CitationRecord, NormalizedCitation } from "./types.js";
-export interface CitationMatchConfig {
+export type CitationMatchConfig = {
     readonly minimumScore: number;
     readonly separationMargin: number;
     readonly clusterSimilarity: number;
     readonly relatedVersionSimilarity: number;
-}
+};
 export declare const DEFAULT_MATCH_CONFIG: CitationMatchConfig;
 export declare function tokenSimilarity(left: string, right: string): number;
 export declare function clusterCitationRecords(input: CitationInput, normalized: NormalizedCitation, records: readonly CitationRecord[], config?: CitationMatchConfig): CitationCandidateCluster[];

package/dist/citations/match.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { presentAt } from "../lib/present.js";
 import { authorNamesMatch, normalizeAuthor, normalizeComparable } from "./normalize.js";
 export const DEFAULT_MATCH_CONFIG = {
     minimumScore: 0.72,
@@ -36,7 +37,11 @@ function authorSimilarity(left, right) {
     return intersection / Math.min(a.length, b.length);
 }
 function identifierEntries(identifiers) {
-    return Object.entries(identifiers).flatMap(([kind, value]) => (value === undefined ? [] : [`${kind}:${value.toLocaleLowerCase("en-US")}`]));
+    // Object.entries types the values as `string`, but a record can carry a key set to
+    // `undefined` (the clients build `identifiers: { doi }` verbatim), so the entry value
+    // is widened to keep the skip of undefined values.
+    const entries = Object.entries(identifiers);
+    return entries.flatMap(([kind, value]) => (value === undefined ? [] : [`${kind}:${value.toLocaleLowerCase("en-US")}`]));
 }
 function sharesStrongIdentifier(left, right) {
     const rightIds = new Set(identifierEntries(right.identifiers));
@@ -69,7 +74,7 @@ class UnionFind {
         this.parent = Array.from({ length: size }, (_, index) => index);
     }
     find(index) {
-        const parent = this.parent[index];
+        const parent = presentAt(this.parent, index, "the parent link");
         if (parent === index)
             return index;
         const root = this.find(parent);
@@ -111,8 +116,8 @@ function containsId(cluster, key) {
 function addRelatedVersions(clusters, config) {
     for (let left = 0; left < clusters.length; left += 1) {
         for (let right = left + 1; right < clusters.length; right += 1) {
-            const a = clusters[left];
-            const b = clusters[right];
+            const a = presentAt(clusters, left, "the left cluster");
+            const b = presentAt(clusters, right, "the right cluster");
             const similarity = Math.max(...a.records.flatMap((one) => b.records.map((two) => recordSimilarity(one, two))));
             if (similarity < config.relatedVersionSimilarity)
                 continue;
@@ -139,8 +144,8 @@ export function clusterCitationRecords(input, normalized, records, config = DEFA
     const union = new UnionFind(records.length);
     for (let left = 0; left < records.length; left += 1) {
         for (let right = left + 1; right < records.length; right += 1) {
-            const a = records[left];
-            const b = records[right];
+            const a = presentAt(records, left, "the left record");
+            const b = presentAt(records, right, "the right record");
             if (sharesStrongIdentifier(a, b))
                 union.union(left, right);
             else if ((!hasStrongIdentifier(a) || !hasStrongIdentifier(b)) && recordSimilarity(a, b) >= config.clusterSimilarity)
@@ -150,7 +155,7 @@ export function clusterCitationRecords(input, normalized, records, config = DEFA
     const grouped = new Map();
     for (let index = 0; index < records.length; index += 1) {
         const root = union.find(index);
-        grouped.set(root, [...(grouped.get(root) ?? []), records[index]]);
+        grouped.set(root, [...(grouped.get(root) ?? []), presentAt(records, index, "the record")]);
     }
     const clusters = [...grouped.values()].map((members) => ({
         id: stableClusterId(members),

package/dist/citations/normalize.js

@@ -1,27 +1,28 @@
 import { CitationInputSchema } from "./types.js";
+import { collapseWhitespace as collapseText, trimTrailingOf } from "../lib/text.js";
 // Each registry defines its own identifier syntax, and each is matched here rather than parsed:
 // a citation string is prose, so the identifier has to be found inside it, not read off a field.
 // The DOI suffix is deliberately permissive — the registry allows nearly any character in it, so
 // there is no delimiter to stop at, and `trimDoiPunctuation` walks back the sentence punctuation
 // and brackets a greedy match swallows. PMID and arXiv anchor instead, having fixed shapes.
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the DOI suffix is deliberately permissive because the registry allows nearly any character in it.
 const DOI_PATTERN = /(?:https?:\/\/(?:dx\.)?doi\.org\/|doi\s*:\s*)?(10\.\d{4,9}\/[^\s<>"']+)/i;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a PMID is a bounded digit run behind an optional `pmid:` prefix.
 const PMID_PATTERN = /^(?:pmid\s*:\s*)?(\d{1,9})$/i;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the two arXiv id shapes (new-style and old-style) behind their optional URL and `arxiv:` spellings.
 const ARXIV_PATTERN = /^(?:https?:\/\/arxiv\.org\/(?:abs|pdf)\/|arxiv\s*:\s*)?((?:\d{4}\.\d{4,5}|[a-z-]+(?:\.[a-z-]+)?\/\d{7})(?:v\d+)?)(?:\.pdf)?$/i;
 function collapseWhitespace(value) {
-    return value.normalize("NFKC").replace(/\s+/g, " ").trim();
+    return collapseText(value.normalize("NFKC"));
 }
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- punctuation and symbols carry no citation identity; they fold to spaces before comparison.
+const PUNCTUATION_AND_SYMBOLS = /[\p{P}\p{S}]+/gu;
 export function normalizeComparable(value) {
-    return collapseWhitespace(value)
-        .toLocaleLowerCase("en-US")
-        .replace(/[\p{P}\p{S}]+/gu, " ")
-        .replace(/\s+/g, " ")
-        .trim();
+    return collapseText(collapseWhitespace(value).toLocaleLowerCase("en-US").replace(PUNCTUATION_AND_SYMBOLS, " "));
 }
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- generational suffixes are noise in author comparison; the word boundaries keep the letters inside longer tokens.
+const NAME_SUFFIX_WORDS = /\b(?:jr|sr|ii|iii|iv)\b/g;
 export function normalizeAuthor(value) {
-    return normalizeComparable(value)
-        .replace(/\b(?:jr|sr|ii|iii|iv)\b/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
+    return collapseText(normalizeComparable(value).replace(NAME_SUFFIX_WORDS, ""));
 }
 function authorEvidence(value) {
     const tokens = normalizeAuthor(value).split(" ").filter(Boolean);
@@ -40,7 +41,7 @@ const SPELLED_OUT_MINIMUM = 3;
  * contributes only the initial it would abbreviate to.
  */
 function givenLetters(leftover, initials) {
-    return [...initials, ...leftover.flatMap((word) => (word.length < SPELLED_OUT_MINIMUM ? [...word] : [word[0]]))].sort();
+    return [...initials, ...leftover.flatMap((word) => (word.length < SPELLED_OUT_MINIMUM ? Array.from(word) : [word.charAt(0)]))].sort();
 }
 function containsLetters(available, required) {
     const pool = [...available];
@@ -81,7 +82,7 @@ export function authorNamesMatch(left, right) {
     return lettersA.length <= lettersB.length ? containsLetters(lettersB, lettersA) : containsLetters(lettersA, lettersB);
 }
 function trimDoiPunctuation(value) {
-    let result = value.replace(/[.,;]+$/g, "");
+    let result = trimTrailingOf(value, ".,;");
     const pairs = [
         ["(", ")"],
         ["[", "]"],
@@ -102,28 +103,36 @@ export function extractDoi(value) {
 export function extractPmid(value) {
     return collapseWhitespace(value).match(PMID_PATTERN)?.[1];
 }
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- an arXiv id carries a version suffix (`v3`) that the registry lookup must not see.
+const ARXIV_VERSION_SUFFIX = /v\d+$/i;
 export function extractArxivId(value) {
     const match = collapseWhitespace(value).match(ARXIV_PATTERN)?.[1];
-    return match?.toLocaleLowerCase("en-US").replace(/v\d+$/i, "");
+    return match?.toLocaleLowerCase("en-US").replace(ARXIV_VERSION_SUFFIX, "");
 }
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the phrase marks a personal communication; the boundaries keep partial words from matching.
+const PERSONAL_COMMUNICATION = /\bpersonal communication\b/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the phrases that mark work with no registered record.
+const UNPUBLISHED_WORK = /\bunpublished (?:data|work|manuscript)\b/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the phrases that mark work accepted but not yet registered.
+const IN_PRESS = /\b(?:in press|forthcoming)\b/;
 function classifyUnsupportedWork(value) {
     const normalized = normalizeComparable(value);
-    if (/\bpersonal communication\b/.test(normalized))
+    if (PERSONAL_COMMUNICATION.test(normalized))
         return "personal_communication";
-    if (/\bunpublished (?:data|work|manuscript)\b/.test(normalized))
+    if (UNPUBLISHED_WORK.test(normalized))
         return "unpublished";
-    if (/\b(?:in press|forthcoming)\b/.test(normalized))
+    if (IN_PRESS.test(normalized))
         return "unregistered_in_press";
     return undefined;
 }
 function normalizedSupplied(input) {
     return {
-        ...(input.title === undefined ? {} : { title: normalizeComparable(input.title) }),
-        ...(input.authors === undefined ? {} : { authors: input.authors.map(normalizeAuthor).filter(Boolean) }),
-        ...(input.year === undefined ? {} : { year: input.year }),
-        ...(input.venue === undefined ? {} : { venue: normalizeComparable(input.venue) }),
-        ...(input.volume === undefined ? {} : { volume: normalizeComparable(input.volume) }),
-        ...(input.firstPage === undefined ? {} : { firstPage: normalizeComparable(input.firstPage) }),
+        title: input.title === undefined ? undefined : normalizeComparable(input.title),
+        authors: input.authors?.map(normalizeAuthor).filter(Boolean),
+        year: input.year,
+        venue: input.venue === undefined ? undefined : normalizeComparable(input.venue),
+        volume: input.volume === undefined ? undefined : normalizeComparable(input.volume),
+        firstPage: input.firstPage === undefined ? undefined : normalizeComparable(input.firstPage),
     };
 }
 export function normalizeCitation(unparsed) {
@@ -155,12 +164,12 @@ export function normalizeCitation(unparsed) {
         query: normalizeComparable(citation),
         kind,
         identifiers: {
-            ...(doi === undefined || !identified ? {} : { doi }),
-            ...(pmid === undefined || !identified ? {} : { pmid }),
-            ...(arxiv === undefined || !identified ? {} : { arxiv }),
+            doi: doi === undefined || !identified ? undefined : doi,
+            pmid: pmid === undefined || !identified ? undefined : pmid,
+            arxiv: arxiv === undefined || !identified ? undefined : arxiv,
         },
         supplied: normalizedSupplied(input),
-        ...(unsupportedWorkKind === undefined ? {} : { unsupportedWorkKind }),
+        unsupportedWorkKind,
     };
 }
 /**

package/dist/citations/plan.js

@@ -1,4 +1,8 @@
 const SOURCES = ["doi_registry", "crossref", "pubmed", "arxiv", "semantic_scholar"];
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the words "arxiv" or "preprint" anywhere in free prose flag a preprint; the boundaries keep them inside longer words out.
+const ARXIV_PREPRINT_HINT = /\b(?:arxiv|preprint)\b/i;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the same hint read off a venue string.
+const ARXIV_VENUE_HINT = /\barxiv\b/i;
 function item(source, applicable, operation, reason, candidateGeneration = false) {
     return { source, applicable, operation: applicable ? operation : "none", candidateGeneration: applicable && candidateGeneration, reason };
 }
@@ -9,11 +13,11 @@ function enoughForEcitMatch(input) {
     return disambiguators >= 2;
 }
 function indicatesArxiv(input, normalized) {
-    return /\b(?:arxiv|preprint)\b/i.test(input.citation) || /\barxiv\b/i.test(input.venue ?? "") || normalized.identifiers.arxiv !== undefined;
+    return ARXIV_PREPRINT_HINT.test(input.citation) || ARXIV_VENUE_HINT.test(input.venue ?? "") || normalized.identifiers.arxiv !== undefined;
 }
 export function planCitationSources(input, normalized) {
     if (normalized.unsupportedWorkKind !== undefined) {
-        return SOURCES.map((source) => item(source, false, "none", `unsupported work kind: ${normalized.unsupportedWorkKind}`));
+        return SOURCES.map((source) => item(source, false, "none", `unsupported work kind: ${String(normalized.unsupportedWorkKind)}`));
     }
     if (normalized.kind === "doi") {
         return [

package/dist/citations/resolve.d.ts

@@ -1,10 +1,10 @@
 import { type CitationMatchConfig } from "./match.js";
 import { type RateLimitConfig, type RateLimitRuntime } from "../lib/rate-limit.js";
 import { type CitationResolver, type CitationSource, type CitationSourceClient } from "./types.js";
-export interface CitationResolverSourceConfig extends Partial<RateLimitConfig> {
+export type CitationResolverSourceConfig = Partial<RateLimitConfig> & {
     readonly enabled?: boolean;
-}
-export interface CitationResolverConfig {
+};
+export type CitationResolverConfig = {
     readonly maxBatchSize?: number;
     readonly timeoutMs?: number;
     readonly cache?: {
@@ -20,9 +20,9 @@ export interface CitationResolverConfig {
     };
     readonly ncbiApiKey?: string;
     readonly semanticScholarApiKey?: string;
-}
-export interface CitationResolverDependencies extends RateLimitRuntime {
+};
+export type CitationResolverDependencies = RateLimitRuntime & {
     readonly fetch?: typeof globalThis.fetch;
     readonly clients?: readonly CitationSourceClient[];
-}
+};
 export declare function createCitationResolver(config?: CitationResolverConfig, deps?: CitationResolverDependencies): CitationResolver;

package/dist/citations/resolve.js

@@ -1,3 +1,5 @@
+import { errorMessageOf, errorOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { aggregateCitationResolution } from "./aggregate.js";
 import { BoundedTtlCache } from "../lib/cache.js";
 import { createArxivCitationClient } from "./clients/arxiv.js";
@@ -10,6 +12,7 @@ import { DEFAULT_MATCH_CONFIG } from "./match.js";
 import { citationLookupKey, normalizeCitation } from "./normalize.js";
 import { planCitationSources } from "./plan.js";
 import { createRateLimitSchedule } from "../lib/rate-limit.js";
+import { presentAt, presentFind, presentFirst, presentGet } from "../lib/present.js";
 import { CitationInputSchema, } from "./types.js";
 const SOURCE_PLAN_VERSION = "citation-plan-v1";
 const SOURCE_ORDER = ["doi_registry", "crossref", "pubmed", "arxiv", "semantic_scholar"];
@@ -21,16 +24,16 @@ const DEFAULT_RATE_LIMITS = {
     semantic_scholar: { maxConcurrency: 1, requestsPerSecond: 1, maxRetries: 2, maxRetryDelayMs: 10_000 },
 };
 function mergedRateLimit(source, config) {
-    return { ...DEFAULT_RATE_LIMITS[source], ...(config.sources?.[source] ?? {}) };
+    return { ...DEFAULT_RATE_LIMITS[source], ...config.sources?.[source] };
 }
 function createDefaultClients(config, deps) {
-    const runtime = { ...(deps.now ? { now: deps.now } : {}), ...(deps.sleep ? { sleep: deps.sleep } : {}) };
+    const runtime = { now: deps.now, sleep: deps.sleep };
     const http = (source) => {
         const limits = mergedRateLimit(source, config);
         return {
-            ...(deps.fetch === undefined ? {} : { fetch: deps.fetch }),
-            ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
-            ...(deps.sleep ? { sleep: deps.sleep } : {}),
+            fetch: deps.fetch,
+            timeoutMs: config.timeoutMs,
+            sleep: deps.sleep,
             schedule: createRateLimitSchedule(limits, runtime),
             maxRetries: limits.maxRetries,
             maxRetryDelayMs: limits.maxRetryDelayMs,
@@ -40,17 +43,17 @@ function createDefaultClients(config, deps) {
         createDoiRegistryClient(http("doi_registry")),
         createCrossrefClient({
             ...http("crossref"),
-            ...(config.crossref?.mailto === undefined ? {} : { mailto: config.crossref.mailto }),
-            ...(config.crossref?.userAgent === undefined ? {} : { userAgent: config.crossref.userAgent }),
+            mailto: config.crossref?.mailto,
+            userAgent: config.crossref?.userAgent,
         }),
         createPubmedCitationClient({
             ...http("pubmed"),
-            ...(config.ncbiApiKey === undefined ? {} : { apiKey: config.ncbiApiKey }),
+            apiKey: config.ncbiApiKey,
         }),
         createArxivCitationClient(http("arxiv")),
         createSemanticScholarCitationClient({
             ...http("semantic_scholar"),
-            ...(config.semanticScholarApiKey === undefined ? {} : { apiKey: config.semanticScholarApiKey }),
+            apiKey: config.semanticScholarApiKey,
         }),
     ];
 }
@@ -60,7 +63,7 @@ function cacheable(outcomes) {
     return outcomes.some((outcome) => outcome.records.length > 0) ? "positive" : "negative";
 }
 function abortReason(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");
 }
 function withCallerSignal(promise, signal) {
     if (signal === undefined)
@@ -75,6 +78,7 @@ function withCallerSignal(promise, signal) {
             resolve(value);
         }, (error) => {
             signal.removeEventListener("abort", onAbort);
+            // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- the rejection reason is the thrown value itself; the awaiter reads its identity, and a wrapper would erase it.
             reject(error);
         });
     });
@@ -105,12 +109,14 @@ function registrationAgencyEvidence(outcome) {
  */
 async function runSource(client, requests, signal) {
     const unavailable = (request, detail) => sourceOutcome(client.source, request.plan.operation, "unavailable", 0, [], detail);
-    const describe = (error) => (error instanceof Error ? error.message : String(error));
+    const describe = (error) => errorMessageOf(error) ?? textOf(error);
     if (client.resolveMany === undefined) {
         const settled = await Promise.allSettled(requests.map((request) => client.resolve(request, signal)));
         if (signal?.aborted)
             throw abortReason(signal);
-        return settled.map((outcome, index) => (outcome.status === "fulfilled" ? outcome.value : unavailable(requests[index], describe(outcome.reason))));
+        return settled.map((outcome, index) => outcome.status === "fulfilled"
+            ? outcome.value
+            : unavailable(presentAt(requests, index, "the request for the settled outcome"), describe(outcome.reason)));
     }
     try {
         const resolved = await client.resolveMany(requests, signal);
@@ -134,7 +140,7 @@ export function createCitationResolver(config = {}, deps = {}) {
     };
     const cache = new BoundedTtlCache(cacheConfig.maximum, now);
     const inFlight = new Map();
-    const matchConfig = { ...DEFAULT_MATCH_CONFIG, ...(config.match ?? {}) };
+    const matchConfig = { ...DEFAULT_MATCH_CONFIG, ...config.match };
     const maxBatchSize = config.maxBatchSize ?? 200;
     const keyFor = (input) => `${SOURCE_PLAN_VERSION}:${citationLookupKey(input)}`;
     async function resolveUncachedBatch(entries, signal) {
@@ -145,10 +151,11 @@ export function createCitationResolver(config = {}, deps = {}) {
             const requests = [];
             const requestIndices = [];
             for (let index = 0; index < entries.length; index += 1) {
-                const entry = entries[index];
-                const plan = entry.plans.find((candidate) => candidate.source === source);
+                const entry = presentAt(entries, index, "the pending citation entry");
+                const entryOutcomes = presentAt(outcomes, index, "the outcome map of the pending citation entry");
+                const plan = presentFind(entry.plans, (candidate) => candidate.source === source, `the plan for ${source}`);
                 if (!plan.applicable || sourceConfig?.enabled === false || client === undefined) {
-                    outcomes[index].set(source, sourceConfig?.enabled === false
+                    entryOutcomes.set(source, sourceConfig?.enabled === false
                         ? notApplicableOutcome({ ...plan, applicable: false, operation: "none", reason: "source disabled by resolver configuration" })
                         : client === undefined
                             ? notApplicableOutcome({ ...plan, applicable: false, operation: "none", reason: "source client unavailable" })
@@ -159,7 +166,7 @@ export function createCitationResolver(config = {}, deps = {}) {
                     input: entry.input,
                     normalized: entry.normalized,
                     plan,
-                    registrationAgency: registrationAgencyEvidence(outcomes[index].get("doi_registry")),
+                    registrationAgency: registrationAgencyEvidence(entryOutcomes.get("doi_registry")),
                 });
                 requestIndices.push(index);
             }
@@ -167,10 +174,12 @@ export function createCitationResolver(config = {}, deps = {}) {
                 continue;
             const resolved = await runSource(client, requests, signal);
             for (let requestIndex = 0; requestIndex < resolved.length; requestIndex += 1) {
-                outcomes[requestIndices[requestIndex]].set(source, resolved[requestIndex]);
+                const entryIndex = presentAt(requestIndices, requestIndex, "the entry index of the request");
+                presentAt(outcomes, entryIndex, "the outcome map of the pending citation entry").set(source, presentAt(resolved, requestIndex, "the resolved outcome"));
             }
         }
-        return entries.map((entry, index) => SOURCE_ORDER.map((source) => outcomes[index].get(source) ?? notApplicableOutcome(entry.plans.find((plan) => plan.source === source))));
+        return entries.map((entry, index) => SOURCE_ORDER.map((source) => presentAt(outcomes, index, "the outcome map of the pending citation entry").get(source) ??
+            notApplicableOutcome(presentFind(entry.plans, (plan) => plan.source === source, `the plan for ${source}`))));
     }
     async function resolveMany(inputs, options = {}) {
         if (inputs.length > maxBatchSize)
@@ -200,15 +209,15 @@ export function createCitationResolver(config = {}, deps = {}) {
                 pending.set(key, running);
                 continue;
             }
-            const input = firstByKey.get(key);
+            const input = presentGet(firstByKey, key, "the first input for the lookup key");
             const normalized = normalizeCitation(input);
             uncached.push({ key, entry: { input, normalized, plans: planCitationSources(input, normalized) } });
         }
         if (uncached.length > 0) {
             const batch = resolveUncachedBatch(uncached.map(({ entry }) => entry), options.signal);
             for (let index = 0; index < uncached.length; index += 1) {
-                const { key } = uncached[index];
-                const one = batch.then((results) => results[index]);
+                const { key } = presentAt(uncached, index, "the uncached entry");
+                const one = batch.then((results) => presentAt(results, index, "the outcome batch of the uncached entry"));
                 const tracked = one.then((outcomes) => {
                     const kind = cacheable(outcomes);
                     if (kind !== undefined)
@@ -225,14 +234,14 @@ export function createCitationResolver(config = {}, deps = {}) {
         }
         const outcomesByKey = new Map();
         await Promise.all(uniqueOrder.map(async (key) => {
-            outcomesByKey.set(key, await withCallerSignal(pending.get(key), options.signal));
+            outcomesByKey.set(key, await withCallerSignal(presentGet(pending, key, "the pending promise for the lookup key"), options.signal));
         }));
         // Aggregated per input, never per shared lookup: comparisons and the
         // verdict they drive belong to the caller's own supplied metadata.
-        return parsed.map((input) => aggregateCitationResolution(input, normalizeCitation(input), outcomesByKey.get(keyFor(input)), matchConfig));
+        return parsed.map((input) => aggregateCitationResolution(input, normalizeCitation(input), presentGet(outcomesByKey, keyFor(input), "the outcomes for the lookup key"), matchConfig));
     }
     return {
-        resolveOne: async (input, options = {}) => (await resolveMany([input], options))[0],
+        resolveOne: async (input, options = {}) => presentFirst(await resolveMany([input], options), "the single resolution"),
         resolveMany,
     };
 }