@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/billing/cached-resolver.d.ts

@@ -12,16 +12,16 @@
  * owns eviction, coalescing, and expiry — the deep, drift-prone plumbing.
  */
 import { ResultAsync } from "neverthrow";
-export interface CachedResolverMetrics {
+export type CachedResolverMetrics = {
     onHit(): void;
     /** Recorded once per upstream fetch — coalesced callers do not count. */
     onMiss(): void;
-}
-export interface CachedResolverConfig<In, Out, E> {
+};
+export type CachedResolverConfig<In, Out, E> = {
     readonly ttlMs: number;
     readonly maxEntries: number;
     readonly keyFn: (input: In) => string;
     readonly fetch: (input: In) => ResultAsync<Out, E>;
     readonly metrics?: CachedResolverMetrics;
-}
+};
 export declare function createCachedResolver<In, Out, E>(cfg: CachedResolverConfig<In, Out, E>): (input: In) => ResultAsync<Out, E>;

package/dist/billing/run-charge.d.ts

@@ -6,21 +6,18 @@
  * external running-charge bracket; OSS wires a no-op. The harness only ever sees this
  * interface — the body brackets the run, the embedder owns the ledger.
  *
- * `open` is a gate: an `err` ends the run before a step starts, or suspends it
- * when the host asks. `close` is a notice: an `err` is logged, and the terminal
+ * `open` is a gate: an `err` ends the run before a step starts, or pauses it
+ * when the host sets the suspend flag. `close` is a notice: an `err` is logged, and the terminal
  * status of the run does not change (see `lib/hooks.ts`).
  */
 import type { ResultAsync } from "neverthrow";
 import type { AgentSession } from "../auth/types.js";
 import type { GateFailure, NoticeFailure } from "../lib/hooks.js";
-/** A suspension carries the reason of the host, which the harness does not read. */
+/** The outcome of a run that ended. A paused run does not end, thus it closes no charge. */
 export type RunChargeOutcome = {
     readonly kind: "ok" | "error" | "canceled";
-} | {
-    readonly kind: "suspended";
-    readonly reason: string;
 };
-export interface RunCharge {
+export type RunCharge = {
     /** Open the run's running charge at init. */
     open(args: {
         analysisId: string;
@@ -34,4 +31,4 @@ export interface RunCharge {
         outcome: RunChargeOutcome;
         session: AgentSession;
     }): ResultAsync<void, NoticeFailure>;
-}
+};

package/dist/billing/run-charge.js

@@ -6,8 +6,8 @@
  * external running-charge bracket; OSS wires a no-op. The harness only ever sees this
  * interface — the body brackets the run, the embedder owns the ledger.
  *
- * `open` is a gate: an `err` ends the run before a step starts, or suspends it
- * when the host asks. `close` is a notice: an `err` is logged, and the terminal
+ * `open` is a gate: an `err` ends the run before a step starts, or pauses it
+ * when the host sets the suspend flag. `close` is a notice: an `err` is logged, and the terminal
  * status of the run does not change (see `lib/hooks.ts`).
  */
 export {};

package/dist/billing/usage-recorder.d.ts

@@ -15,16 +15,16 @@ import type { Scope } from "../auth/types.js";
 import type { NoticeFailure } from "../lib/hooks.js";
 import type { ChatUsage } from "../providers/types.js";
 /** One completed LLM call's token usage, with the attribution held at the call site. */
-export interface LlmUsageRecord {
+export type LlmUsageRecord = {
     /**
      * Idempotency key. Stable across every replay of the same call: under a
      * `RunFrame` it composes the `runId`, the frame's `stepId` when it carries
      * one, the session's provenance call path, the dispatching tool call's id
-     * when the loop runs nested inside one, and the loop's deterministic step
-     * name; outside a `RunFrame` (the chat path, where no replay exists) it is
-     * freshly minted. Every component past the frame is load-bearing, because
-     * a step name is unique only within one loop invocation and loops routinely
-     * share a frame: the `stepId` keeps sibling step workflows of one run
+     * when the loop runs nested inside one, and the response id of the call,
+     * which the checkpoint of the call keeps; outside a `RunFrame` (the chat
+     * path, where no replay exists) it is freshly minted. Every component past
+     * the frame is load-bearing, because loops routinely share a frame: the
+     * `stepId` keeps sibling step workflows of one run
      * apart, the call path keeps distinct agent chains under one frame apart,
      * and the invocation id keeps parallel dispatches of one sub-agent apart.
      * The harness guarantees key stability, not at-most-once delivery —
@@ -48,7 +48,7 @@ export interface LlmUsageRecord {
     readonly servedModelId?: string;
     /** What the provider reported. Unreported figures stay absent, never zeroed. */
     readonly usage: ChatUsage;
-}
+};
 /**
  * Records one `LlmUsageRecord` per completed LLM call.
  *
@@ -59,6 +59,6 @@ export interface LlmUsageRecord {
  * make a run slower, but a realization that throws before it returns a
  * `ResultAsync` still fails the run it was only meant to observe.
  */
-export interface UsageRecorder {
+export type UsageRecorder = {
     record(record: LlmUsageRecord): ResultAsync<void, NoticeFailure>;
-}
+};

package/dist/citations/aggregate.js

@@ -35,7 +35,7 @@ export function aggregateCitationResolution(input, normalized, sourceOutcomes, m
         normalized,
         sourceOutcomes: [...sourceOutcomes],
         candidates,
-        ...(selected === undefined ? {} : { selectedClusterId: selected.id }),
+        selectedClusterId: selected?.id,
         comparisons,
         conflicts: detectCitationConflicts(candidates),
         verdict,

package/dist/citations/clients/arxiv.d.ts

@@ -1,6 +1,6 @@
 import type { CitationSourceClient } from "../types.js";
 import type { SourceHttpOptions } from "../../literature/sources/http.js";
-export interface ArxivCitationClientOptions extends SourceHttpOptions {
+export type ArxivCitationClientOptions = SourceHttpOptions & {
     readonly maxCandidates?: number;
-}
+};
 export declare function createArxivCitationClient(options?: ArxivCitationClientOptions): CitationSourceClient;

package/dist/citations/clients/arxiv.js

@@ -10,7 +10,7 @@ function arxivRecord(paper) {
         identifiers: { arxiv: identifier },
         title: paper.title,
         authors: paper.authors,
-        ...(year === undefined ? {} : { year }),
+        year,
         venue: "arXiv",
         url: paper.url,
     };
@@ -22,9 +22,17 @@ export function createArxivCitationClient(options = {}) {
         async resolve(request, signal) {
             if (!request.plan.applicable)
                 return sourceOutcome("arxiv", request.plan.operation, "not_applicable", 0, [], request.plan.reason);
-            const result = request.plan.operation === "arxiv_exact"
-                ? await source.lookupExact(request.normalized.identifiers.arxiv, options.maxCandidates ?? 5, signal)
-                : await source.search({ query: request.input.title ?? request.input.citation, limit: options.maxCandidates ?? 5 }, signal);
+            if (request.plan.operation === "arxiv_exact") {
+                const arxivId = request.normalized.identifiers.arxiv;
+                if (arxivId === undefined)
+                    return sourceOutcome("arxiv", request.plan.operation, "unavailable", 0, [], "the exact plan carries no arXiv identifier");
+                const result = await source.lookupExact(arxivId, options.maxCandidates ?? 5, signal);
+                if (result.status !== "ok")
+                    return sourceOutcome("arxiv", request.plan.operation, result.status, 1, [], result.detail);
+                const records = result.value.map(arxivRecord);
+                return sourceOutcome("arxiv", request.plan.operation, records.length === 0 ? "no_data" : "ok", 1, records);
+            }
+            const result = await source.search({ query: request.input.title ?? request.input.citation, limit: options.maxCandidates ?? 5 }, signal);
             if (result.status !== "ok")
                 return sourceOutcome("arxiv", request.plan.operation, result.status, 1, [], result.detail);
             const records = result.value.map(arxivRecord);

package/dist/citations/clients/common.js

@@ -1,3 +1,5 @@
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a publication year stands alone in untyped metadata; the boundaries keep the tail of a longer number out.
+const YEAR_PATTERN = /\b(1[5-9]\d{2}|20\d{2}|21\d{2})\b/;
 export function notApplicableOutcome(plan) {
     return {
         source: plan.source,
@@ -15,7 +17,7 @@ export function sourceOutcome(source, operation, status, requestCount, records =
         status,
         requestCount,
         records,
-        ...(detail === undefined ? {} : { detail }),
+        detail,
     };
 }
 /**
@@ -31,7 +33,7 @@ export function parseYear(value) {
         return value;
     if (typeof value !== "string")
         return undefined;
-    const match = value.match(/\b(1[5-9]\d{2}|20\d{2}|21\d{2})\b/);
+    const match = value.match(YEAR_PATTERN);
     return match?.[1] === undefined ? undefined : Number(match[1]);
 }
 export function firstNonEmpty(values) {

package/dist/citations/clients/crossref.d.ts

@@ -1,8 +1,8 @@
 import type { CitationSourceClient } from "../types.js";
 import { type SourceHttpOptions } from "../../literature/sources/http.js";
-export interface CrossrefClientOptions extends SourceHttpOptions {
+export type CrossrefClientOptions = SourceHttpOptions & {
     readonly mailto?: string;
     readonly userAgent?: string;
     readonly maxCandidates?: number;
-}
+};
 export declare function createCrossrefClient(options?: CrossrefClientOptions): CitationSourceClient;

package/dist/citations/clients/crossref.js

@@ -1,21 +1,20 @@
 import { z } from "zod";
 import { encodeDoiPath, firstNonEmpty, parseYear, sourceOutcome } from "./common.js";
+import { firstSegmentOf } from "../../lib/text.js";
 import { requestJson } from "../../literature/sources/http.js";
-const CrossrefItemSchema = z
-    .object({
+const CrossrefItemSchema = z.looseObject({
     DOI: z.string().optional(),
     URL: z.string().optional(),
     title: z.array(z.string()).optional(),
-    author: z.array(z.object({ given: z.string().optional(), family: z.string().optional(), name: z.string().optional() }).passthrough()).optional(),
+    author: z.array(z.looseObject({ given: z.string().optional(), family: z.string().optional(), name: z.string().optional() })).optional(),
     issued: z.object({ "date-parts": z.array(z.array(z.number())).optional() }).optional(),
     published: z.object({ "date-parts": z.array(z.array(z.number())).optional() }).optional(),
     "container-title": z.array(z.string()).optional(),
     volume: z.string().optional(),
     page: z.string().optional(),
-})
-    .passthrough();
+});
 const ExactSchema = z.object({ message: CrossrefItemSchema });
-const SearchSchema = z.object({ message: z.object({ items: z.array(CrossrefItemSchema) }).passthrough() });
+const SearchSchema = z.object({ message: z.looseObject({ items: z.array(CrossrefItemSchema) }) });
 function crossrefRecord(item, index) {
     const doi = item.DOI?.toLocaleLowerCase("en-US");
     const sourceRecordId = firstNonEmpty([doi, item.URL, `candidate-${index}`]);
@@ -30,14 +29,14 @@ function crossrefRecord(item, index) {
     return {
         source: "crossref",
         sourceRecordId,
-        identifiers: { ...(doi === undefined ? {} : { doi }) },
-        ...(title === undefined ? {} : { title }),
-        ...(authors === undefined || authors.length === 0 ? {} : { authors }),
-        ...(dateParts?.[0] === undefined ? {} : { year: parseYear(dateParts[0]) }),
-        ...(venue === undefined ? {} : { venue }),
-        ...(item.volume === undefined ? {} : { volume: item.volume }),
-        ...(item.page === undefined ? {} : { firstPage: item.page.split(/[-–]/)[0] }),
-        ...(item.URL === undefined ? {} : { url: item.URL }),
+        identifiers: { doi },
+        title,
+        authors: authors !== undefined && authors.length > 0 ? authors : undefined,
+        year: dateParts?.[0] === undefined ? undefined : parseYear(dateParts[0]),
+        venue,
+        volume: item.volume,
+        firstPage: firstSegmentOf(item.page, "-–"),
+        url: item.URL,
     };
 }
 export function createCrossrefClient(options = {}) {
@@ -66,29 +65,30 @@ export function createCrossrefClient(options = {}) {
             }
             const doi = request.normalized.identifiers.doi;
             const exact = request.plan.operation === "crossref_doi_if_owned";
-            const url = exact
-                ? (() => {
-                    const target = new URL(`https://api.crossref.org/works/${encodeDoiPath(doi)}`);
-                    if (options.mailto)
-                        target.searchParams.set("mailto", options.mailto);
-                    return target.toString();
-                })()
-                : (() => {
-                    const params = new URLSearchParams({
-                        "query.bibliographic": request.input.citation,
-                        rows: String(options.maxCandidates ?? 5),
-                    });
-                    if (options.mailto)
-                        params.set("mailto", options.mailto);
-                    return `https://api.crossref.org/works?${params}`;
-                })();
-            const result = exact
-                ? await requestJson(url, ExactSchema, options, signal, { headers })
-                : await requestJson(url, SearchSchema, options, signal, { headers });
-            if (result.status !== "ok")
-                return sourceOutcome("crossref", request.plan.operation, result.status, 1, [], result.detail);
-            const items = exact ? [result.value.message] : result.value.message.items;
-            const records = items.flatMap((item, index) => {
+            let url;
+            if (exact) {
+                if (doi === undefined)
+                    return sourceOutcome("crossref", request.plan.operation, "unavailable", 0, [], "the exact plan carries no DOI");
+                const target = new URL(`https://api.crossref.org/works/${encodeDoiPath(doi)}`);
+                if (options.mailto)
+                    target.searchParams.set("mailto", options.mailto);
+                url = target.toString();
+            }
+            else {
+                const params = new URLSearchParams({
+                    "query.bibliographic": request.input.citation,
+                    rows: String(options.maxCandidates ?? 5),
+                });
+                if (options.mailto)
+                    params.set("mailto", options.mailto);
+                url = `https://api.crossref.org/works?${params}`;
+            }
+            const fetched = exact
+                ? await requestJson(url, ExactSchema, options, signal, { headers }).then((result) => result.status === "ok" ? { status: "ok", value: [result.value.message] } : result)
+                : await requestJson(url, SearchSchema, options, signal, { headers }).then((result) => result.status === "ok" ? { status: "ok", value: result.value.message.items } : result);
+            if (fetched.status !== "ok")
+                return sourceOutcome("crossref", request.plan.operation, fetched.status, 1, [], fetched.detail);
+            const records = fetched.value.flatMap((item, index) => {
                 const record = crossrefRecord(item, index);
                 return record === undefined ? [] : [record];
             });

package/dist/citations/clients/doi-registry.js

@@ -1,22 +1,21 @@
 import { z } from "zod";
 import { encodeDoiPath, firstNonEmpty, parseYear, sourceOutcome } from "./common.js";
+import { firstSegmentOf } from "../../lib/text.js";
 import { requestJson } from "../../literature/sources/http.js";
-const HandleResponseSchema = z.object({ responseCode: z.number() }).passthrough();
-const RegistrationAgencySchema = z.array(z.object({ DOI: z.string().optional(), RA: z.string().optional() }).passthrough());
-const CslMetadataSchema = z
-    .object({
+const HandleResponseSchema = z.looseObject({ responseCode: z.number() });
+const RegistrationAgencySchema = z.array(z.looseObject({ DOI: z.string().optional(), RA: z.string().optional() }));
+const CslMetadataSchema = z.looseObject({
     DOI: z.string().optional(),
     id: z.string().optional(),
     title: z.union([z.string(), z.array(z.string())]).optional(),
-    author: z.array(z.object({ given: z.string().optional(), family: z.string().optional(), literal: z.string().optional() }).passthrough()).optional(),
+    author: z.array(z.looseObject({ given: z.string().optional(), family: z.string().optional(), literal: z.string().optional() })).optional(),
     issued: z.object({ "date-parts": z.array(z.array(z.number())).optional() }).optional(),
     published: z.object({ "date-parts": z.array(z.array(z.number())).optional() }).optional(),
     "container-title": z.union([z.string(), z.array(z.string())]).optional(),
     volume: z.string().optional(),
     page: z.string().optional(),
     URL: z.string().optional(),
-})
-    .passthrough();
+});
 function scalar(value) {
     return Array.isArray(value) ? firstNonEmpty(value) : firstNonEmpty([value]);
 }
@@ -31,14 +30,14 @@ function cslRecord(doi, registrationAgency, metadata) {
         source: "doi_registry",
         sourceRecordId: doi,
         identifiers: { doi },
-        ...(title === undefined ? {} : { title }),
-        ...(authors === undefined || authors.length === 0 ? {} : { authors }),
-        ...(dateParts?.[0] === undefined ? {} : { year: parseYear(dateParts[0]) }),
-        ...(venue === undefined ? {} : { venue }),
-        ...(metadata?.volume === undefined ? {} : { volume: metadata.volume }),
-        ...(metadata?.page === undefined ? {} : { firstPage: metadata.page.split(/[-–]/)[0] }),
-        ...(registrationAgency === undefined ? {} : { registrationAgency }),
-        ...(metadata?.URL === undefined ? {} : { url: metadata.URL }),
+        title,
+        authors: authors !== undefined && authors.length > 0 ? authors : undefined,
+        year: dateParts?.[0] === undefined ? undefined : parseYear(dateParts[0]),
+        venue,
+        volume: metadata?.volume,
+        firstPage: firstSegmentOf(metadata?.page, "-–"),
+        registrationAgency,
+        url: metadata?.URL,
     };
 }
 export function createDoiRegistryClient(options = {}) {
@@ -86,7 +85,7 @@ export function createDoiRegistryClient(options = {}) {
                     type: "doi",
                     identifier: doi,
                     exists: true,
-                    ...(registrationAgency === undefined ? {} : { registrationAgency }),
+                    registrationAgency,
                     metadataAvailable: metadata !== undefined,
                 },
             };

package/dist/citations/clients/pubmed.d.ts

@@ -1,6 +1,6 @@
 import type { CitationSourceClient } from "../types.js";
 import { type PubmedSourceOptions } from "../../literature/sources/pubmed.js";
-export interface PubmedCitationClientOptions extends PubmedSourceOptions {
+export type PubmedCitationClientOptions = PubmedSourceOptions & {
     readonly maxCandidates?: number;
-}
+};
 export declare function createPubmedCitationClient(options?: PubmedCitationClientOptions): CitationSourceClient;

package/dist/citations/clients/pubmed.js

@@ -5,11 +5,11 @@ function pubmedRecord(article) {
     return {
         source: "pubmed",
         sourceRecordId: article.pmid,
-        identifiers: { pmid: article.pmid, ...(article.doi ? { doi: article.doi.toLocaleLowerCase("en-US") } : {}) },
-        ...(article.title ? { title: article.title } : {}),
-        ...(article.authors.length === 0 ? {} : { authors: article.authors }),
-        ...(year === undefined ? {} : { year }),
-        ...(article.journal ? { venue: article.journal } : {}),
+        identifiers: { pmid: article.pmid, doi: article.doi ? article.doi.toLocaleLowerCase("en-US") : undefined },
+        title: article.title ? article.title : undefined,
+        authors: article.authors.length > 0 ? article.authors : undefined,
+        year,
+        venue: article.journal ? article.journal : undefined,
         url: `https://pubmed.ncbi.nlm.nih.gov/${article.pmid}/`,
     };
 }
@@ -21,16 +21,19 @@ export function createPubmedCitationClient(options = {}) {
         let requestCount = 0;
         let pmids;
         if (request.plan.operation === "pubmed_exact") {
-            pmids = [request.normalized.identifiers.pmid];
+            const pmid = request.normalized.identifiers.pmid;
+            if (pmid === undefined)
+                return sourceOutcome("pubmed", request.plan.operation, "unavailable", 0, [], "the exact plan carries no PMID");
+            pmids = [pmid];
         }
         else if (request.plan.operation === "pubmed_structured") {
             requestCount += 1;
             const match = await source.matchCitation({
-                ...(request.input.venue === undefined ? {} : { venue: request.input.venue }),
-                ...(request.input.year === undefined ? {} : { year: request.input.year }),
-                ...(request.input.volume === undefined ? {} : { volume: request.input.volume }),
-                ...(request.input.firstPage === undefined ? {} : { firstPage: request.input.firstPage }),
-                ...(request.input.authors?.[0] === undefined ? {} : { firstAuthor: request.input.authors[0] }),
+                venue: request.input.venue,
+                year: request.input.year,
+                volume: request.input.volume,
+                firstPage: request.input.firstPage,
+                firstAuthor: request.input.authors?.[0],
                 key: "citation-0",
             }, signal);
             if (match.status !== "ok")
@@ -39,7 +42,7 @@ export function createPubmedCitationClient(options = {}) {
         }
         else {
             requestCount += 1;
-            const term = request.plan.operation === "pubmed_doi" ? `${request.normalized.identifiers.doi}[AID]` : `${request.input.title ?? ""}[Title]`;
+            const term = request.plan.operation === "pubmed_doi" ? `${String(request.normalized.identifiers.doi)}[AID]` : `${request.input.title ?? ""}[Title]`;
             const search = await source.searchIds(term, options.maxCandidates ?? 5, signal);
             if (search.status !== "ok")
                 return sourceOutcome("pubmed", request.plan.operation, search.status, requestCount, [], search.detail);
@@ -77,7 +80,11 @@ export function createPubmedCitationClient(options = {}) {
             if (results[index] === undefined)
                 results[index] = await resolve(request, signal);
         }));
-        return results.map((result) => result);
+        return results.map((result) => {
+            if (result === undefined)
+                throw new Error("the pubmed batch left an outcome unresolved");
+            return result;
+        });
     }
     return { source: "pubmed", resolve, resolveMany };
 }

package/dist/citations/clients/semantic-scholar.d.ts

@@ -1,6 +1,6 @@
 import type { CitationSourceClient } from "../types.js";
 import { type SemanticScholarSourceOptions } from "../../literature/sources/semantic-scholar.js";
-export interface SemanticScholarCitationClientOptions extends SemanticScholarSourceOptions {
+export type SemanticScholarCitationClientOptions = SemanticScholarSourceOptions & {
     readonly maxCandidates?: number;
-}
+};
 export declare function createSemanticScholarCitationClient(options?: SemanticScholarCitationClientOptions): CitationSourceClient;

package/dist/citations/clients/semantic-scholar.js

@@ -13,16 +13,16 @@ function semanticRecord(paper) {
         source: "semantic_scholar",
         sourceRecordId: paper.id,
         identifiers: {
-            ...(doi === undefined ? {} : { doi }),
-            ...(pmid === undefined ? {} : { pmid }),
-            ...(arxiv === undefined ? {} : { arxiv }),
-            ...(corpusId === undefined ? {} : { corpusId }),
+            doi,
+            pmid,
+            arxiv,
+            corpusId,
         },
-        ...(paper.title === undefined ? {} : { title: paper.title }),
-        ...(paper.authors.length === 0 ? {} : { authors: paper.authors }),
-        ...(paper.year === undefined ? {} : { year: paper.year }),
-        ...(paper.venue === undefined ? {} : { venue: paper.venue }),
-        ...(paper.url === undefined ? {} : { url: paper.url }),
+        title: paper.title,
+        authors: paper.authors.length > 0 ? paper.authors : undefined,
+        year: paper.year,
+        venue: paper.venue,
+        url: paper.url,
     };
 }
 export function createSemanticScholarCitationClient(options = {}) {

package/dist/citations/compare.js

@@ -10,7 +10,7 @@ function recordValue(record, field) {
     return record[field];
 }
 function normalizedValue(field, value) {
-    if (field === "authors")
+    if (field === "authors" && Array.isArray(value))
         return value.map(normalizeAuthor).sort().join("|");
     if (field === "year")
         return String(value);
@@ -20,7 +20,7 @@ function authorMatch(supplied, source) {
     return supplied.every((author) => source.some((candidate) => authorNamesMatch(author, candidate)));
 }
 function fieldMatches(field, supplied, source) {
-    if (field === "authors")
+    if (field === "authors" && Array.isArray(supplied) && Array.isArray(source))
         return authorMatch(supplied, source);
     if (field === "year")
         return Math.abs(Number(supplied) - Number(source)) <= 1;

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),