jbrowse-plugin-msaview 3.3.0 → 3.4.1

package/dist/utils/blastCache.d.ts

@@ -1,15 +1,18 @@
-import type { BlastDatabase, MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
+import type { BlastDatabase, MsaAlgorithm, PhmmerDatabase, SearchProgram } from '../LaunchMsaView/components/BlastQuery/consts';
 export interface CachedBlastResult {
     id: string;
     proteinSequence: string;
-    blastDatabase: BlastDatabase;
+    blastDatabase: BlastDatabase | PhmmerDatabase;
     /**
      * Only ever set on rows cached by a version that still queried NCBI, where
      * the choice between blastp and quick-blastp was real. Kept so those rows
      * still display; never written now.
      */
     blastProgram?: string;
-    msaAlgorithm: MsaAlgorithm;
+    /** absent on rows cached before phmmer existed, which were all blastp */
+    searchProgram?: SearchProgram;
+    /** absent on phmmer rows, which are aligned by the search itself */
+    msaAlgorithm?: MsaAlgorithm;
     msa: string;
     tree: string;
     treeMetadata: string;
@@ -20,10 +23,11 @@ export interface CachedBlastResult {
     transcriptName?: string;
     geneName?: string;
 }
-export declare function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
+export declare function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
     proteinSequence: string;
-    blastDatabase: BlastDatabase;
-    msaAlgorithm: MsaAlgorithm;
+    blastDatabase: BlastDatabase | PhmmerDatabase;
+    msaAlgorithm?: MsaAlgorithm;
+    searchProgram?: SearchProgram;
     msa: string;
     tree: string;
     treeMetadata: string;

package/dist/utils/blastCache.js

@@ -2,6 +2,12 @@ import { createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-blast-cache';
 const STORE_NAME = 'blast-results';
 const DB_VERSION = 2;
+/**
+ * How many results the history keeps. Every row holds a whole alignment and its
+ * tree — megabytes each — so an unbounded store grows until the browser starts
+ * refusing writes to it, and the user never sees why.
+ */
+const MAX_CACHED_RESULTS = 50;
 const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
     if (oldVersion < 2 && db.objectStoreNames.contains(STORE_NAME)) {
         db.deleteObjectStore(STORE_NAME);
@@ -10,21 +16,33 @@ const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
         db.createObjectStore(STORE_NAME, { keyPath: 'id' });
     }
 });
-function createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId) {
+function createCacheKey({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, transcriptId, }) {
     const idPart = transcriptId ? `:${transcriptId}` : '';
+    // phmmer keys are prefixed and blastp keys are left exactly as they were, so
+    // results cached before phmmer existed still resolve
+    if (searchProgram === 'phmmer') {
+        return `phmmer:${blastDatabase}${idPart}:${proteinSequence}`;
+    }
     // msaAlgorithm is part of the key because the stored msa/tree are produced by
     // it — without it, re-running the same query under a different algorithm
     // overwrites the earlier result and drops it from the history list
     return `${blastDatabase}:${msaAlgorithm}${idPart}:${proteinSequence}`;
 }
-export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
+export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
     const db = await getDB();
-    const id = createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId);
+    const id = createCacheKey({
+        proteinSequence,
+        blastDatabase,
+        msaAlgorithm,
+        searchProgram,
+        transcriptId,
+    });
     const entry = {
         id,
         proteinSequence,
         blastDatabase,
         msaAlgorithm,
+        searchProgram,
         msa,
         tree,
         treeMetadata,
@@ -36,8 +54,34 @@ export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgor
         geneName,
     };
     await db.put(STORE_NAME, entry);
+    await evictOldest(db);
     return entry;
 }
+/**
+ * Drop the oldest rows until the store is back at MAX_CACHED_RESULTS.
+ *
+ * `count` first so the common save reads no values at all: without a timestamp
+ * index the oldest have to be found by loading every row, and each one is an
+ * entire alignment. Failing to evict must not fail the save — the result is
+ * already in hand and losing it to a housekeeping error would be the worse
+ * outcome.
+ */
+async function evictOldest(db) {
+    try {
+        if ((await db.count(STORE_NAME)) <= MAX_CACHED_RESULTS) {
+            return;
+        }
+        const all = await db.getAll(STORE_NAME);
+        const doomed = all
+            .toSorted((a, b) => a.timestamp - b.timestamp)
+            .slice(0, all.length - MAX_CACHED_RESULTS);
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        await Promise.all([...doomed.map(e => tx.store.delete(e.id)), tx.done]);
+    }
+    catch (e) {
+        console.warn('Failed to evict old BLAST cache entries:', e);
+    }
+}
 export async function getAllCachedResults() {
     const db = await getDB();
     const results = await db.getAll(STORE_NAME);

package/dist/utils/blastCache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/blastCache.test.js

@@ -0,0 +1,72 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { getAllCachedResults, saveBlastResult } from './blastCache';
+// An in-memory stand-in for the one object store this module opens. Only the
+// idb calls blastCache makes are implemented; anything else would be untested
+// scaffolding.
+const { rows } = vi.hoisted(() => ({
+    rows: new Map(),
+}));
+vi.mock('./idb', () => ({
+    createDbOpener: () => () => Promise.resolve({
+        put: (_store, value) => {
+            rows.set(value.id, value);
+            return Promise.resolve(value.id);
+        },
+        count: () => Promise.resolve(rows.size),
+        getAll: () => Promise.resolve([...rows.values()]),
+        transaction: () => ({
+            store: {
+                delete: (id) => {
+                    rows.delete(id);
+                    return Promise.resolve();
+                },
+            },
+            done: Promise.resolve(),
+        }),
+    }),
+}));
+function save(n) {
+    return saveBlastResult({
+        proteinSequence: `SEQ${n}`,
+        blastDatabase: 'uniprotkb_swissprot',
+        msaAlgorithm: 'clustalo',
+        msa: '>a\nMK',
+        tree: '(a);',
+        treeMetadata: '{}',
+        rid: `job-${n}`,
+    });
+}
+beforeEach(() => {
+    rows.clear();
+    // strictly increasing, so "oldest" is unambiguous -- 55 saves in one
+    // millisecond would otherwise all carry the same timestamp
+    let clock = 1;
+    vi.spyOn(Date, 'now').mockImplementation(() => clock++);
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+test('a store at the cap loses nothing', async () => {
+    for (let i = 0; i < 50; i++) {
+        await save(i);
+    }
+    expect(rows.size).toBe(50);
+});
+// Every row holds a whole alignment and its tree, so an unbounded store grows
+// until the browser refuses writes to it and the user never learns why.
+test('going over the cap drops the oldest results and keeps the newest 50', async () => {
+    for (let i = 0; i < 55; i++) {
+        await save(i);
+    }
+    expect(rows.size).toBe(50);
+    const rids = (await getAllCachedResults()).map((r) => r.rid);
+    expect(rids.at(0)).toBe('job-54');
+    expect(rids.at(-1)).toBe('job-5');
+});
+test('re-saving the same query overwrites its row rather than growing the store', async () => {
+    for (let i = 0; i < 50; i++) {
+        await save(i);
+    }
+    await save(0);
+    expect(rows.size).toBe(50);
+});

package/dist/utils/ebiBlast.d.ts

@@ -1,5 +1,5 @@
-import type { BlastHit } from './types';
 import type { BlastDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
+import type { BlastHit } from './types';
 /**
  * The subset of EBI's ncbiblast JSON result this plugin reads. The service
  * returns a great deal more per hit (urls, bit scores, e-values, the match
@@ -33,18 +33,20 @@ export declare function normalizeEbiBlastHits(result: EbiBlastJson): BlastHit[];
  * yet at the moment the link is on screen.
  */
 export declare function ebiBlastResultUrl(jobId: string): string;
-export declare function queryEbiBlastFromJobId({ jobId, onProgress, }: {
+export declare function queryEbiBlastFromJobId({ jobId, onProgress, signal, }: {
     jobId: string;
     onProgress: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     rid: string;
     hits: BlastHit[];
 }>;
-export declare function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }: {
+export declare function queryEbiBlast({ query, blastDatabase, onProgress, onRid, signal, }: {
     query: string;
     blastDatabase: BlastDatabase;
     onProgress: (arg: string) => void;
     onRid: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     rid: string;
     hits: BlastHit[];

package/dist/utils/ebiBlast.js

@@ -32,22 +32,23 @@ export function normalizeEbiBlastHits(result) {
 export function ebiBlastResultUrl(jobId) {
     return `https://www.ebi.ac.uk/jdispatcher/sss/${TOOL}/summary?jobId=${jobId}`;
 }
-export async function queryEbiBlastFromJobId({ jobId, onProgress, }) {
+export async function queryEbiBlastFromJobId({ jobId, onProgress, signal, }) {
     onProgress(`Checking BLAST status for job: ${jobId}...`);
     await waitForEbiJob({
         tool: TOOL,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking BLAST status in... ${s}`);
         },
     });
-    const hits = normalizeEbiBlastHits(JSON.parse(await fetchEbiResult({ tool: TOOL, jobId, type: 'json' })));
+    const hits = normalizeEbiBlastHits(JSON.parse(await fetchEbiResult({ tool: TOOL, jobId, type: 'json', signal })));
     if (hits.length === 0) {
         throw new Error('No hits found');
     }
     return { rid: jobId, hits };
 }
-export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }) {
+export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, signal, }) {
     onProgress('Submitting to EBI BLAST...');
     const jobId = await submitEbiJob({
         tool: TOOL,
@@ -57,7 +58,8 @@ export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }
             database: blastDatabase,
             sequence: query,
         },
+        signal,
     });
     onRid(jobId);
-    return queryEbiBlastFromJobId({ jobId, onProgress });
+    return queryEbiBlastFromJobId({ jobId, onProgress, signal });
 }

package/dist/utils/ebiJobDispatcher.d.ts

@@ -16,18 +16,21 @@ export declare const EBI_BASE = "https://www.ebi.ac.uk/Tools/services/rest";
 export declare const EBI_EMAIL_STORAGE_KEY = "msa-ebiContactEmail";
 export declare const DEFAULT_EBI_EMAIL = "colin.diesh@gmail.com";
 export declare function getEbiEmail(): string;
-export declare function submitEbiJob({ tool, params, }: {
+export declare function submitEbiJob({ tool, params, signal, }: {
     tool: string;
     params: Record<string, string>;
+    signal?: AbortSignal;
 }): Promise<string>;
-export declare function waitForEbiJob({ tool, jobId, intervalSeconds, onCountdown, }: {
+export declare function waitForEbiJob({ tool, jobId, intervalSeconds, onCountdown, signal, }: {
     tool: string;
     jobId: string;
     intervalSeconds?: number;
     onCountdown: (secondsRemaining: number) => void;
+    signal?: AbortSignal;
 }): Promise<void>;
-export declare function fetchEbiResult({ tool, jobId, type, }: {
+export declare function fetchEbiResult({ tool, jobId, type, signal, }: {
     tool: string;
     jobId: string;
     type: string;
+    signal?: AbortSignal;
 }): Promise<string>;

package/dist/utils/ebiJobDispatcher.js

@@ -1,4 +1,4 @@
-import { textfetch } from './fetch';
+import { isAbortError, textfetch } from './fetch';
 import { pollLoop } from './poll';
 import { readLocalStorage } from './useLocalStorage';
 /**
@@ -24,10 +24,11 @@ export function getEbiEmail() {
 }
 /** Statuses that mean the job is over and produced no result. */
 const FAILED_STATUSES = new Set(['ERROR', 'FAILURE', 'NOT_FOUND']);
-export async function submitEbiJob({ tool, params, }) {
+export async function submitEbiJob({ tool, params, signal, }) {
     const jobId = await textfetch(`${EBI_BASE}/${tool}/run`, {
         method: 'POST',
         body: new URLSearchParams({ email: getEbiEmail(), ...params }),
+        signal,
     });
     return jobId.trim();
 }
@@ -43,17 +44,23 @@ export async function submitEbiJob({ tool, params, }) {
  * away must not be polled forever.
  */
 const MAX_CONSECUTIVE_STATUS_FAILURES = 5;
-export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, }) {
+export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, signal, }) {
     let consecutiveFailures = 0;
     await pollLoop({
         intervalSeconds,
         onCountdown,
+        signal,
         check: async () => {
             let status;
             try {
-                status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim();
+                status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`, { signal })).trim();
             }
             catch (e) {
+                // a cancelled request is the caller giving up, not EBI being
+                // unreachable, so it must end the poll rather than be retried
+                if (isAbortError(e)) {
+                    throw e;
+                }
                 consecutiveFailures += 1;
                 if (consecutiveFailures >= MAX_CONSECUTIVE_STATUS_FAILURES) {
                     throw new Error(`Could not reach EBI to check ${tool} job ${jobId} after ${consecutiveFailures} tries`, { cause: e });
@@ -75,6 +82,6 @@ export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCount
         },
     });
 }
-export async function fetchEbiResult({ tool, jobId, type, }) {
-    return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`);
+export async function fetchEbiResult({ tool, jobId, type, signal, }) {
+    return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`, { signal });
 }

package/dist/utils/fetch.d.ts

@@ -1,4 +1,11 @@
 export declare function handleFetch(url: string, args?: RequestInit): Promise<Response>;
 export declare function textfetch(url: string, args?: RequestInit): Promise<string>;
 export declare function jsonfetch<T>(url: string, args?: RequestInit): Promise<T>;
-export declare function timeout(time: number): Promise<unknown>;
+export declare function timeout(time: number, signal?: AbortSignal): Promise<void>;
+/**
+ * A cancelled launch has to be told apart from a failed one: it must not render
+ * the "failed" panel, and it must not touch a model that may already be gone.
+ * `fetch` and the sleep above both reject with a DOMException named AbortError,
+ * which subclasses Error.
+ */
+export declare function isAbortError(e: unknown): boolean;

package/dist/utils/fetch.js

@@ -36,6 +36,32 @@ export async function jsonfetch(url, args) {
     const response = await handleFetch(url, args);
     return response.json();
 }
-export function timeout(time) {
-    return new Promise(res => setTimeout(res, time));
+export function timeout(time, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DOMException('Aborted', 'AbortError'));
+            return;
+        }
+        // the listener is removed on the natural path too: one signal serves every
+        // tick of a poll, and a 10-minute job is ~600 sleeps -- leaving each
+        // listener behind accumulates them all on that one signal
+        const onAbort = () => {
+            clearTimeout(id);
+            reject(new DOMException('Aborted', 'AbortError'));
+        };
+        const id = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, time);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * A cancelled launch has to be told apart from a failed one: it must not render
+ * the "failed" panel, and it must not touch a model that may already be gone.
+ * `fetch` and the sleep above both reject with a DOMException named AbortError,
+ * which subclasses Error.
+ */
+export function isAbortError(e) {
+    return e instanceof Error && e.name === 'AbortError';
 }

package/dist/utils/msa.d.ts

@@ -1,8 +1,22 @@
 import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
-export declare function launchMSA({ algorithm, sequence, onProgress, }: {
+/**
+ * Build a tree from an alignment that already exists, which is what the phmmer
+ * path needs: phmmer produces the alignment itself, so there is no aligner run
+ * to take a guide tree from — and a guide tree is a byproduct of deciding
+ * progressive alignment order, not a phylogeny, so it is not what we would want
+ * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
+ * a real distance matrix, Kimura-corrected for protein distances.
+ */
+export declare function launchTree({ alignment, onProgress, signal, }: {
+    alignment: string;
+    onProgress: (arg: string) => void;
+    signal?: AbortSignal;
+}): Promise<string>;
+export declare function launchMSA({ algorithm, sequence, onProgress, signal, }: {
     algorithm: MsaAlgorithm;
     sequence: string;
     onProgress: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     msa: string;
     tree: string;

package/dist/utils/msa.js

@@ -21,30 +21,57 @@ const algorithms = {
         treeResult: 'phylotree',
     },
 };
-export async function launchMSA({ algorithm, sequence, onProgress, }) {
+/**
+ * Build a tree from an alignment that already exists, which is what the phmmer
+ * path needs: phmmer produces the alignment itself, so there is no aligner run
+ * to take a guide tree from — and a guide tree is a byproduct of deciding
+ * progressive alignment order, not a phylogeny, so it is not what we would want
+ * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
+ * a real distance matrix, Kimura-corrected for protein distances.
+ */
+export async function launchTree({ alignment, onProgress, signal, }) {
+    const tool = 'simple_phylogeny';
+    onProgress('Building tree...');
+    const jobId = await submitEbiJob({
+        tool,
+        params: {
+            sequence: alignment,
+            tree: 'phylip',
+            clustering: 'Neighbour-joining',
+            kimura: 'true',
+        },
+        signal,
+    });
+    await waitForEbiJob({
+        tool,
+        jobId,
+        signal,
+        onCountdown: s => {
+            onProgress(`Re-checking tree status in... ${s}`);
+        },
+    });
+    return fetchEbiResult({ tool, jobId, type: 'tree', signal });
+}
+export async function launchMSA({ algorithm, sequence, onProgress, signal, }) {
     const config = algorithms[algorithm];
     onProgress(`Launching ${algorithm} MSA...`);
     const jobId = await submitEbiJob({
         tool: algorithm,
         params: { ...config.params, sequence },
+        signal,
     });
     await waitForEbiJob({
         tool: algorithm,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking MSA status in... ${s}`);
         },
     });
-    return {
-        msa: await fetchEbiResult({
-            tool: algorithm,
-            jobId,
-            type: config.msaResult,
-        }),
-        tree: await fetchEbiResult({
-            tool: algorithm,
-            jobId,
-            type: config.treeResult,
-        }),
-    };
+    // one finished job, two result files, neither derived from the other
+    const [msa, tree] = await Promise.all([
+        fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult, signal }),
+        fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult, signal }),
+    ]);
+    return { msa, tree };
 }

package/dist/utils/msaRows.d.ts

@@ -0,0 +1,31 @@
+import type { PhmmerRow } from './phmmer';
+import type { TaxonomyInfo } from './taxonomyNames';
+import type { BlastHitDescription } from './types';
+/**
+ * Turning search results into the rows the view is given, kept free of any
+ * jbrowse or network import so the whole assembly can be run and checked
+ * outside a browser — see test/phmmerLive.test.ts.
+ */
+export declare function buildRowMetadata(desc: BlastHitDescription, taxonomyInfo: Map<number, TaxonomyInfo>): Record<string, string>;
+/**
+ * One target can match the query in several places and phmmer emits a row per
+ * matched envelope — four for lamprey albumin against human albumin, which has
+ * three domains. Those rows share an accession and so would share a name, and
+ * duplicate names silently collapse rows in both the MSA and the tree, so the
+ * envelope disambiguates them.
+ */
+export declare function makeRowNames(rows: PhmmerRow[], taxonomyInfo: Map<number, TaxonomyInfo>): string[];
+/**
+ * The phmmer alignment as the view receives it: aligned FASTA whose first row
+ * is the query, plus the per-row metadata keyed by the same names, which are
+ * also what the tree's leaves are labelled with.
+ */
+export declare function buildPhmmerMsa({ rows, queryRow, taxonomyInfo, querySeqName, }: {
+    rows: PhmmerRow[];
+    queryRow: string;
+    taxonomyInfo: Map<number, TaxonomyInfo>;
+    querySeqName?: string;
+}): {
+    msa: string;
+    treeMetadata: Record<string, Record<string, string>>;
+};

package/dist/utils/msaRows.js

@@ -0,0 +1,67 @@
+import { makeId } from '../LaunchMsaView/components/util';
+/**
+ * Turning search results into the rows the view is given, kept free of any
+ * jbrowse or network import so the whole assembly can be run and checked
+ * outside a browser — see test/phmmerLive.test.ts.
+ */
+export function buildRowMetadata(desc, taxonomyInfo) {
+    const metadata = {};
+    const taxInfo = desc.taxid ? taxonomyInfo.get(desc.taxid) : undefined;
+    if (taxInfo?.sciname) {
+        metadata['Scientific name'] = taxInfo.sciname;
+    }
+    if (taxInfo?.commonName) {
+        metadata['Common name'] = taxInfo.commonName;
+    }
+    if (desc.accession) {
+        metadata.Accession = desc.accession;
+    }
+    if (desc.id) {
+        metadata.ID = desc.id;
+    }
+    if (desc.title) {
+        metadata.Description = desc.title;
+    }
+    return metadata;
+}
+/**
+ * One target can match the query in several places and phmmer emits a row per
+ * matched envelope — four for lamprey albumin against human albumin, which has
+ * three domains. Those rows share an accession and so would share a name, and
+ * duplicate names silently collapse rows in both the MSA and the tree, so the
+ * envelope disambiguates them.
+ */
+export function makeRowNames(rows, taxonomyInfo) {
+    const baseNames = rows.map(row => makeId(row, taxonomyInfo));
+    const counts = new Map();
+    for (const name of baseNames) {
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const used = new Set();
+    return baseNames.map((base, i) => {
+        let name = counts.get(base) > 1 ? `${base}_${rows[i].range ?? i + 1}` : base;
+        while (used.has(name)) {
+            name = `${name}_${i + 1}`;
+        }
+        used.add(name);
+        return name;
+    });
+}
+/**
+ * The phmmer alignment as the view receives it: aligned FASTA whose first row
+ * is the query, plus the per-row metadata keyed by the same names, which are
+ * also what the tree's leaves are labelled with.
+ */
+export function buildPhmmerMsa({ rows, queryRow, taxonomyInfo, querySeqName = 'QUERY', }) {
+    const treeMetadata = {};
+    const rowNames = makeRowNames(rows, taxonomyInfo);
+    const sequences = rows.map((row, i) => {
+        const rowName = rowNames[i];
+        treeMetadata[rowName] = buildRowMetadata(row, taxonomyInfo);
+        return `>${rowName}\n${row.aligned}`;
+    });
+    return {
+        msa: [`>${querySeqName}\n${queryRow}`, ...sequences].join('\n'),
+        treeMetadata,
+    };
+}

package/dist/utils/ncbiDomains.d.ts

@@ -5,11 +5,11 @@ export type DomainMatch = InterProScanResults['matches'][number];
  * domain and site annotations, keyed by both the versioned and primary
  * accession so callers can look up by whichever NCBI returned.
  */
-export declare function parseCddDomains(xml: string): Map<string, import("msa-parsers").InterProScanMatch[]>;
+export declare function parseCddDomains(xml: string): Map<string, DomainMatch[]>;
 /**
  * Fetch pre-computed CDD domain and site annotations for NCBI protein
  * accessions. These come baked into the GenPept records, so a single batched
  * efetch returns them with no job submission or polling. Results are cached in
  * IndexedDB so reopening a view doesn't refetch.
  */
-export declare function fetchProteinDomains(accessions: string[]): Promise<Map<string, import("msa-parsers").InterProScanMatch[]>>;
+export declare function fetchProteinDomains(accessions: string[]): Promise<Map<string, DomainMatch[]>>;

package/dist/utils/ncbiOrthologs.d.ts

@@ -10,6 +10,13 @@ export interface OrthologRow {
     protein: string;
     sequence: string;
 }
+/**
+ * A candidate gene reference as the ortholog services know it: a GFF ID prefix
+ * (gene:TP53) and a version suffix (NM_000546.6) stripped off. Shared with
+ * pantherOrthologs, which asks PANTHER the same question with the same
+ * candidates.
+ */
+export declare function cleanGeneCandidate(raw: string): string;
 /**
  * A free-text gene reference -> NCBI gene id. A bare number is taken as the id
  * itself; anything else is searched as a gene name within the query taxon.
@@ -50,7 +57,10 @@ export declare function parseFasta(text: string): Map<string, string>;
  * Sanitized, unique single-token labels used identically in the FASTA headers,
  * the tree leaf names and the domain GFF seq_ids — that identity is how the
  * viewer pairs a tree leaf to its alignment row to its domain track. Collisions
- * get a numeric suffix rather than silently overwriting a row.
+ * get a numeric suffix rather than silently overwriting a row, and the suffix
+ * climbs past labels already emitted: a species genuinely named `human_2` would
+ * otherwise take the label the second `human` is about to get, merging two rows
+ * into one.
  */
 export declare function dedupeLabels(names: string[]): string[];
 /**