@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/auth/types.d.ts

@@ -21,9 +21,9 @@
  * `providers/request-headers.ts`).
  */
 /** Who the request is. Always complete. */
-export interface Identity {
+export type Identity = {
     readonly user: string;
-}
+};
 /**
  * What the request operates on. It owns its resource coordinates
  * (`scopeResource`) and the workload id (`scopeWorkloadId`) used for
@@ -43,27 +43,27 @@ declare const CRED_BRAND: unique symbol;
  * off it while still letting a concrete managed credential satisfy it
  * structurally.
  */
-export interface Credential {
+export type Credential = {
     readonly [CRED_BRAND]?: never;
-}
+};
 /**
  * The agent call chain at the point of a call. Read-only provenance —
  * events, logs, and OTel spans read it; control flow MUST NOT branch on it.
  */
-export interface Provenance {
+export type Provenance = {
     readonly agentId: string;
     readonly callPath: readonly string[];
-}
+};
 /** Present only inside a workflow run. */
-export interface RunFrame {
+export type RunFrame = {
     readonly runId: string;
     readonly stepId?: string;
-}
+};
 /** Canonical resource coordinates a `Scope` resolves to. */
-export interface ResourceCoordinates {
+export type ResourceCoordinates = {
     readonly resourceType: "analysis";
     readonly resourceId: string;
-}
+};
 /** Derive the `{ resourceType, resourceId }` a scope resolves through: `{ "analysis", analysisId }`. */
 export declare function scopeResource(scope: Scope): ResourceCoordinates;
 /** The value stamped into the workload tag — the workload id for this scope. */
@@ -79,14 +79,14 @@ declare const AUTH_BRAND: unique symbol;
  * off it while still letting a managed `{ credential, orgId }` literal satisfy
  * it structurally.
  */
-export interface AuthContext {
+export type AuthContext = {
     readonly [AUTH_BRAND]?: never;
-}
+};
 /**
  * The session view the agent loop, the provider seam, and tools accept —
  * the union of what every layer below the HTTP door actually reads. The
- * session is a conduit: `runAgent` forwards it to the provider and into each
- * tool; tools forward it to `embed` and into nested `runAgent`s. The deepest
+ * session is a conduit: `runLoop` forwards it to the provider and into each
+ * tool; tools forward it to `embed` and into nested `runLoop`s. The deepest
  * consumer is the provider, which reads every field, so the conduit type is
  * "all fields, generalized to what's read" — `credential` widened to the
  * opaque `Credential` (nothing in the harness branches on the concrete shape),
@@ -96,7 +96,7 @@ export interface AuthContext {
  * `RunSession` (with RunFrame) are each structurally assignable, so the
  * same agent loop runs under a live request and inside a durable workflow.
  */
-export interface AgentSession {
+export type AgentSession = {
     readonly identity: Identity;
     readonly scope: Scope;
     readonly provenance: Provenance;
@@ -107,57 +107,57 @@ export interface AgentSession {
      * `getAuth`. The sole source of credential/org behind a session.
      */
     readonly auth: AuthContext;
-}
+};
 /**
  * The live HTTP door. No `RunFrame` — `runId`/`stepId` are unrepresentable
  * until async work is authorized. SHALL NOT be JSON-serialized into durable
  * state.
  */
-export interface RequestSession {
+export type RequestSession = {
     readonly identity: Identity;
     readonly scope: Scope;
     readonly provenance: Provenance;
     readonly auth: AuthContext;
-}
+};
 /**
  * The durable, JSON-serializable bundle. Carries a `RunFrame`. Constructed
  * solely at the run-authorization seam.
  */
-export interface RunSession {
+export type RunSession = {
     readonly identity: Identity;
     readonly scope: Scope;
     readonly provenance: Provenance;
     readonly runFrame: RunFrame;
     readonly auth: AuthContext;
-}
+};
 /**
  * The session of a sandbox spawn. A sandbox takes its analysis id, its run id,
  * and its step id from this session.
  */
-export interface SpawnSession extends RunSession {
+export type SpawnSession = RunSession & {
     readonly runFrame: RunFrame & {
         readonly stepId: string;
     };
-}
+};
 /**
  * The minimal session view that a host hook reads. Both bundles satisfy it;
  * `runFrame` is present only on a `RunSession`, so a hook that gets a
  * `RequestSession` sees no run or step.
  */
-export interface HookSessionView {
+export type HookSessionView = {
     readonly identity: Identity;
     readonly scope: Scope;
     readonly provenance: Provenance;
     readonly runFrame?: RunFrame;
-}
+};
 /**
  * The session that the request headers hook gets: the hook view plus the
  * opaque `auth`, which a host realization downcasts to reach its credential.
  * `AgentSession` structurally satisfies it.
  */
-export interface ResolvableSession extends HookSessionView {
+export type ResolvableSession = HookSessionView & {
     readonly auth: AuthContext;
-}
+};
 /**
  * Derive a child session for a sub-agent call — provenance only. Sets the
  * child `agentId` and appends it to `callPath`, leaving identity, scope, and

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;