jbrowse-plugin-msaview 3.2.0 → 3.4.0

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

@@ -10,21 +10,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,

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

package/dist/utils/msa.d.ts

@@ -1,4 +1,16 @@
 import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
+/**
+ * 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, }: {
+    alignment: string;
+    onProgress: (arg: string) => void;
+}): Promise<string>;
 export declare function launchMSA({ algorithm, sequence, onProgress, }: {
     algorithm: MsaAlgorithm;
     sequence: string;

package/dist/utils/msa.js

@@ -21,6 +21,35 @@ const algorithms = {
         treeResult: 'phylotree',
     },
 };
+/**
+ * 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, }) {
+    const tool = 'simple_phylogeny';
+    onProgress('Building tree...');
+    const jobId = await submitEbiJob({
+        tool,
+        params: {
+            sequence: alignment,
+            tree: 'phylip',
+            clustering: 'Neighbour-joining',
+            kimura: 'true',
+        },
+    });
+    await waitForEbiJob({
+        tool,
+        jobId,
+        onCountdown: s => {
+            onProgress(`Re-checking tree status in... ${s}`);
+        },
+    });
+    return fetchEbiResult({ tool, jobId, type: 'tree' });
+}
 export async function launchMSA({ algorithm, sequence, onProgress, }) {
     const config = algorithms[algorithm];
     onProgress(`Launching ${algorithm} MSA...`);
@@ -35,16 +64,10 @@ export async function launchMSA({ algorithm, sequence, onProgress, }) {
             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 }),
+        fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult }),
+    ]);
+    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/pantherOrthologs.d.ts

@@ -0,0 +1,79 @@
+import type { OrthologRow } from './ncbiOrthologs';
+export interface PantherGenome {
+    /** PANTHER's organism code, e.g. HUMAN, DROME */
+    code: string;
+    taxId: number;
+    /** short common name, e.g. fruit_fly */
+    name: string;
+    /** scientific name */
+    longName: string;
+}
+/**
+ * `supportedgenomes` -> the code<->taxon map every other parse needs. PANTHER
+ * names organisms by code only in ortholog results.
+ */
+export declare function parseGenomes(json: unknown): PantherGenome[];
+export interface PantherGene {
+    code: string;
+    /** UniProt accession */
+    accession: string;
+    /** the source database's own id, e.g. HGNC=1773, FlyBase=FBgn0016131 */
+    geneRef: string;
+}
+export interface PantherHit extends PantherGene {
+    symbol?: string;
+    /**
+     * LDO = least diverged ortholog, PANTHER's pick of the one-to-one; O = any
+     * other ortholog in a one-to-many or many-to-many family
+     */
+    type: 'LDO' | 'O';
+}
+/**
+ * `matchortho` -> the query gene (PANTHER names it in every row) and one hit
+ * per target gene. An unknown gene comes back under `unmapped_ids`; a gene with
+ * no ortholog in the target set comes back as a bare `{ id }`.
+ */
+export declare function parseMatches(json: unknown): {
+    unmapped: boolean;
+    query?: PantherGene;
+    hits: PantherHit[];
+};
+/**
+ * One hit per organism, in first-seen order: the LDO where PANTHER named one,
+ * else the first other ortholog it listed. A many-to-many family (the Hox
+ * genes) has no LDO at all, so dropping to "first O" is what keeps those
+ * species in the alignment.
+ */
+export declare function pickOnePerGenome(hits: PantherHit[]): PantherHit[];
+/** `uniprotkb/accessions` -> accession -> sequence */
+export declare function parseSequences(json: unknown): Map<string, string>;
+/** The proteome list, fetched once per page and forgotten on failure. */
+export declare function fetchGenomes(): Promise<PantherGenome[]>;
+export interface PantherOrthologs {
+    /** the candidate PANTHER recognised */
+    matched: string;
+    /** the query gene as PANTHER knows it, with its UniProt sequence */
+    query?: PantherGene & {
+        sequence: string;
+    };
+    rows: OrthologRow[];
+}
+/**
+ * The whole PANTHER half of the pipeline: gene -> ortholog rows carrying
+ * labels, accessions and sequences, plus the query gene's own protein for the
+ * query row. Two lookups (genomes, orthologs), one taxonomy batch for the
+ * labels, one UniProt batch for the sequences.
+ *
+ * `taxa`, `exclude` and `limit` mean what they mean for fetchOrthologRows:
+ * `taxa` narrows the targets (omitted, every genome PANTHER has, in its order),
+ * `exclude` drops the query taxon, `limit` caps the rows before their
+ * sequences are fetched.
+ */
+export declare function fetchPantherOrthologs({ candidates, taxId, taxa, exclude, limit, onProgress, }: {
+    candidates: string[];
+    taxId: number;
+    taxa?: Set<number>;
+    exclude?: number;
+    limit?: number;
+    onProgress: (arg: string) => void;
+}): Promise<PantherOrthologs>;

package/dist/utils/pantherOrthologs.js

@@ -0,0 +1,262 @@
+// The second ortholog source, for the genes NCBI's ortholog sets leave out.
+//
+// NCBI Datasets computes orthologs for vertebrates and insects, so a yeast,
+// worm or plant gene comes back with orthologs only in its own clade, and a fly
+// gene gets insects and nothing else. PANTHER's ortholog sets span its 144
+// reference proteomes, human to yeast to Arabidopsis, and one `matchortho` call
+// answers "this gene's ortholog in every genome" with a UniProt accession per
+// target. Sequences come from one UniProt batch call. Both hosts send
+// `Access-Control-Allow-Origin: *`. The measurements that picked PANTHER over
+// OMA, OrthoDB and Ensembl are in react-msaview's
+// agent-docs/ideas/ortholog-sources-beyond-ncbi.md.
+//
+// Rows come out in the same shape as ncbiOrthologs.ts's, so the launch, the
+// labels, the aligner and the CDD overlay do not know which source ran.
+// `protein` is the UniProt accession; efetch serves UniProt accessions as
+// GenPept records with CDD Region features, so the overlay attaches as it does
+// to a RefSeq accession.
+import { jsonfetch } from './fetch';
+import { dedupeLabels, defaultMaxSpecies } from './ncbiOrthologs';
+import { fetchTaxonomyInfo } from './taxonomyNames';
+const PANTHER = 'https://pantherdb.org/services/oai/pantherdb';
+const UNIPROT = 'https://rest.uniprot.org/uniprotkb';
+/**
+ * `supportedgenomes` -> the code<->taxon map every other parse needs. PANTHER
+ * names organisms by code only in ortholog results.
+ */
+export function parseGenomes(json) {
+    const list = json.search?.output?.genomes?.genome ?? [];
+    return list.flatMap(g => g.short_name && g.taxon_id
+        ? [
+            {
+                code: g.short_name,
+                taxId: g.taxon_id,
+                name: g.name ?? g.short_name,
+                longName: g.long_name ?? g.short_name,
+            },
+        ]
+        : []);
+}
+// "HUMAN|HGNC=1773|UniProtKB=P11802" -> { code, geneRef, accession }
+function parseGeneRef(ref) {
+    const [code, ...xrefs] = (ref ?? '').split('|');
+    const accession = xrefs
+        .find(x => x.startsWith('UniProtKB='))
+        ?.slice('UniProtKB='.length);
+    const geneRef = xrefs.find(x => !x.startsWith('UniProtKB=')) ?? accession;
+    return code && accession && geneRef ? { code, accession, geneRef } : undefined;
+}
+/**
+ * `matchortho` -> the query gene (PANTHER names it in every row) and one hit
+ * per target gene. An unknown gene comes back under `unmapped_ids`; a gene with
+ * no ortholog in the target set comes back as a bare `{ id }`.
+ */
+export function parseMatches(json) {
+    const mapping = json.search?.mapping;
+    const mapped = mapping?.mapped;
+    const rows = Array.isArray(mapped) ? mapped : mapped ? [mapped] : [];
+    const hits = [];
+    let query;
+    for (const row of rows) {
+        query ??= parseGeneRef(row.gene);
+        const target = parseGeneRef(row.target_gene);
+        if (target && (row.ortholog === 'LDO' || row.ortholog === 'O')) {
+            hits.push({
+                ...target,
+                symbol: row.target_gene_symbol === undefined
+                    ? undefined
+                    : String(row.target_gene_symbol),
+                type: row.ortholog,
+            });
+        }
+    }
+    return { unmapped: !!mapping?.unmapped_ids, query, hits };
+}
+/**
+ * One hit per organism, in first-seen order: the LDO where PANTHER named one,
+ * else the first other ortholog it listed. A many-to-many family (the Hox
+ * genes) has no LDO at all, so dropping to "first O" is what keeps those
+ * species in the alignment.
+ */
+export function pickOnePerGenome(hits) {
+    const byCode = new Map();
+    for (const hit of hits) {
+        const current = byCode.get(hit.code);
+        if (!current || (current.type === 'O' && hit.type === 'LDO')) {
+            byCode.set(hit.code, hit);
+        }
+    }
+    return [...byCode.values()];
+}
+/** `uniprotkb/accessions` -> accession -> sequence */
+export function parseSequences(json) {
+    const map = new Map();
+    for (const r of json.results ?? []) {
+        if (r.primaryAccession && r.sequence?.value) {
+            map.set(r.primaryAccession, r.sequence.value);
+        }
+    }
+    return map;
+}
+let genomes;
+/** The proteome list, fetched once per page and forgotten on failure. */
+export function fetchGenomes() {
+    genomes ??= jsonfetch(`${PANTHER}/supportedgenomes`)
+        .then(parseGenomes)
+        .catch((e) => {
+        genomes = undefined;
+        throw e;
+    });
+    return genomes;
+}
+// UniProt caps one `accessions` call at 100 ids
+const UNIPROT_CHUNK = 100;
+async function fetchSequences(accessions) {
+    const map = new Map();
+    for (let i = 0; i < accessions.length; i += UNIPROT_CHUNK) {
+        const chunk = accessions.slice(i, i + UNIPROT_CHUNK);
+        const json = await jsonfetch(`${UNIPROT}/accessions?accessions=${chunk.join(',')}&fields=accession,sequence&format=json`);
+        for (const [acc, seq] of parseSequences(json)) {
+            map.set(acc, seq);
+        }
+    }
+    return map;
+}
+// strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53), as
+// resolveGeneId does for NCBI
+function cleanCandidate(raw) {
+    return raw
+        .trim()
+        .replace(/^\w+:/, '')
+        .replace(/\.\d+$/, '');
+}
+/**
+ * One `matchortho` per candidate until PANTHER maps one. A JBrowse feature
+ * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
+ * some of those are names PANTHER knows. `targets` omitted asks for every
+ * genome PANTHER has, which is one call rather than one per genome.
+ */
+async function matchOrthologs(candidates, taxId, targets) {
+    let matched;
+    for (const raw of candidates) {
+        const query = cleanCandidate(raw);
+        if (!query) {
+            continue;
+        }
+        const params = new URLSearchParams({
+            geneInputList: query,
+            organism: String(taxId),
+            orthologType: 'all',
+        });
+        if (targets) {
+            params.set('targetOrganism', targets.map(t => t.taxId).join(','));
+        }
+        const parsed = parseMatches(await jsonfetch(`${PANTHER}/ortholog/matchortho?${params.toString()}`));
+        if (!parsed.unmapped) {
+            matched ??= query;
+            if (parsed.query) {
+                return { ...parsed, matched: query };
+            }
+        }
+    }
+    return matched === undefined
+        ? undefined
+        : { matched, hits: [], query: undefined };
+}
+/**
+ * The whole PANTHER half of the pipeline: gene -> ortholog rows carrying
+ * labels, accessions and sequences, plus the query gene's own protein for the
+ * query row. Two lookups (genomes, orthologs), one taxonomy batch for the
+ * labels, one UniProt batch for the sequences.
+ *
+ * `taxa`, `exclude` and `limit` mean what they mean for fetchOrthologRows:
+ * `taxa` narrows the targets (omitted, every genome PANTHER has, in its order),
+ * `exclude` drops the query taxon, `limit` caps the rows before their
+ * sequences are fetched.
+ */
+export async function fetchPantherOrthologs({ candidates, taxId, taxa, exclude, limit = defaultMaxSpecies, onProgress, }) {
+    const all = await fetchGenomes();
+    const byTaxId = new Map(all.map(g => [g.taxId, g]));
+    const byCode = new Map(all.map(g => [g.code, g]));
+    const queryGenome = byTaxId.get(taxId);
+    if (!queryGenome) {
+        throw new Error(`PANTHER has no reference proteome for taxon ${taxId}. NCBI orthologs cover vertebrates and insects; try that source.`);
+    }
+    const targets = taxa
+        ? [...taxa].flatMap(t => {
+            const g = byTaxId.get(t);
+            return g && t !== exclude ? [g] : [];
+        })
+        : undefined;
+    onProgress('Matching orthologs at PANTHER...');
+    const match = await matchOrthologs(candidates, taxId, targets);
+    if (!match) {
+        throw new Error(`PANTHER has no entry for ${candidates.join(', ')} in ${queryGenome.longName}. Try the NCBI BLAST tab, which needs no gene identifier.`);
+    }
+    const rank = new Map(targets?.map((t, i) => [t.taxId, i]));
+    const picks = pickOnePerGenome(match.hits)
+        .map(hit => ({ hit, genome: byCode.get(hit.code) }))
+        .filter((p) => !!p.genome &&
+        p.genome.taxId !== exclude &&
+        (targets ? rank.has(p.genome.taxId) : true))
+        .sort((a, b) => targets ? rank.get(a.genome.taxId) - rank.get(b.genome.taxId) : 0)
+        .slice(0, limit);
+    if (picks.length < 2) {
+        throw new Error(`Only ${picks.length} PANTHER ortholog(s) found for ${match.matched} — not enough to align`);
+    }
+    onProgress(`Fetching ${picks.length} protein sequences from UniProt...`);
+    const [names, sequences] = await Promise.all([
+        taxonomyNames(picks.map(p => p.genome.taxId)),
+        fetchSequences([
+            ...(match.query ? [match.query.accession] : []),
+            ...picks.map(p => p.hit.accession),
+        ]),
+    ]);
+    const described = picks.map(({ hit, genome }) => {
+        const info = names.get(genome.taxId);
+        return {
+            hit,
+            genome,
+            name: info ? (info.commonName ?? info.sciname) : genome.name,
+            scientificName: info?.sciname || genome.longName,
+            commonName: info?.commonName,
+        };
+    });
+    const labels = dedupeLabels(described.map(d => d.name));
+    const rows = described
+        .map(({ hit, genome, scientificName, commonName }, i) => ({
+        taxId: genome.taxId,
+        label: labels[i],
+        scientificName,
+        commonName,
+        geneId: hit.geneRef,
+        protein: hit.accession,
+        sequence: sequences.get(hit.accession) ?? '',
+    }))
+        .filter(r => r.sequence);
+    if (rows.length < 2) {
+        throw new Error('Could not fetch protein sequences for the orthologs');
+    }
+    const querySequence = match.query && sequences.get(match.query.accession);
+    return {
+        matched: match.matched,
+        query: match.query && querySequence
+            ? { ...match.query, sequence: querySequence }
+            : undefined,
+        rows,
+    };
+}
+/**
+ * NCBI's names for the taxa, so PANTHER rows are labelled exactly as NCBI rows
+ * are. A failed lookup only costs the labels, which fall back to PANTHER's own
+ * short names, so it is logged rather than thrown.
+ */
+async function taxonomyNames(taxIds) {
+    try {
+        return await fetchTaxonomyInfo(taxIds);
+    }
+    catch (e) {
+        console.warn('[msaview-orthologs] taxonomy name lookup failed:', e);
+        return new Map();
+    }
+}

package/dist/utils/phmmer.d.ts

@@ -0,0 +1,53 @@
+import type { PhmmerDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
+export interface PhmmerRow {
+    accession: string;
+    id: string;
+    sciname: string;
+    taxid?: number;
+    title?: string;
+    /** the matched envelope on the target, e.g. '503-912', absent if unparseable */
+    range?: string;
+    /** the row as phmmer aligned it, uppercased with '.' inserts turned into '-' */
+    aligned: string;
+}
+export interface PhmmerAlignment {
+    rows: PhmmerRow[];
+    /**
+     * the query, placed into the same columns. phmmer does not put the query in
+     * its own output, so this is derived — see buildQueryRow.
+     */
+    queryRow: string;
+}
+/**
+ * Human-facing link to a job, shown while it runs and on error.
+ *
+ * The category has to be sss: jdispatcher serves its shell with a 200 for any
+ * category, so /pfa/ and /psa/ look fine to a fetch and render "Page Not Found"
+ * in a browser.
+ */
+export declare function phmmerResultUrl(jobId: string): string;
+/** EBI job ids are prefixed with the tool that made them */
+export declare function isPhmmerJobId(jobId: string): boolean;
+/**
+ * Exported for testing against a captured .sto — the annotation names (RF, the
+ * DE line's OS=/OX=) are the whole risk in this mapping, and nothing else in CI
+ * would notice if HMMER or EBI changed one.
+ */
+export declare function parsePhmmerAlignment({ stockholm, query, }: {
+    stockholm: string;
+    query: string;
+}): PhmmerAlignment;
+export declare function queryPhmmer({ query, database, onProgress, onRid, }: {
+    query: string;
+    database: PhmmerDatabase;
+    onProgress: (arg: string) => void;
+    onRid: (arg: string) => void;
+}): Promise<{
+    rows: PhmmerRow[];
+    /**
+     * the query, placed into the same columns. phmmer does not put the query in
+     * its own output, so this is derived — see buildQueryRow.
+     */
+    queryRow: string;
+    rid: string;
+}>;