jbrowse-plugin-msaview 2.7.2 → 2.7.4

package/dist/utils/blastCache.d.ts

@@ -29,6 +29,5 @@ export declare function saveBlastResult({ proteinSequence, blastDatabase, blastP
     transcriptName?: string;
     geneName?: string;
 }): Promise<CachedBlastResult>;
-export declare function getAllCachedResults(): Promise<any[]>;
+export declare function getAllCachedResults(): Promise<CachedBlastResult[]>;
 export declare function deleteCachedResult(id: string): Promise<void>;
-export declare function clearAllCachedResults(): Promise<void>;

package/dist/utils/blastCache.js

@@ -1,24 +1,15 @@
-import { openDB } from 'idb';
+import { createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-blast-cache';
 const STORE_NAME = 'blast-results';
 const DB_VERSION = 2;
-let dbPromise;
-function getDB() {
-    dbPromise ??= openDB(DB_NAME, DB_VERSION, {
-        upgrade(db, oldVersion) {
-            if (oldVersion < 2 && db.objectStoreNames.contains(STORE_NAME)) {
-                db.deleteObjectStore(STORE_NAME);
-            }
-            if (!db.objectStoreNames.contains(STORE_NAME)) {
-                db.createObjectStore(STORE_NAME, { keyPath: 'id' });
-            }
-        },
-    }).catch((e) => {
-        dbPromise = undefined;
-        throw e;
-    });
-    return dbPromise;
-}
+const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
+    if (oldVersion < 2 && db.objectStoreNames.contains(STORE_NAME)) {
+        db.deleteObjectStore(STORE_NAME);
+    }
+    if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'id' });
+    }
+});
 function createCacheKey(proteinSequence, blastDatabase, blastProgram, msaAlgorithm, transcriptId) {
     const idPart = transcriptId ? `:${transcriptId}` : '';
     // msaAlgorithm is part of the key because the stored msa/tree are produced by
@@ -57,7 +48,3 @@ export async function deleteCachedResult(id) {
     const db = await getDB();
     await db.delete(STORE_NAME, id);
 }
-export async function clearAllCachedResults() {
-    const db = await getDB();
-    await db.clear(STORE_NAME);
-}

package/dist/utils/domainCache.js

@@ -1,21 +1,12 @@
-import { openDB } from 'idb';
+import { createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-domain-cache';
 const STORE_NAME = 'domains';
 const DB_VERSION = 1;
-let dbPromise;
-function getDB() {
-    dbPromise ??= openDB(DB_NAME, DB_VERSION, {
-        upgrade(db) {
-            if (!db.objectStoreNames.contains(STORE_NAME)) {
-                db.createObjectStore(STORE_NAME, { keyPath: 'accession' });
-            }
-        },
-    }).catch((e) => {
-        dbPromise = undefined;
-        throw e;
-    });
-    return dbPromise;
-}
+const getDB = createDbOpener(DB_NAME, DB_VERSION, db => {
+    if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'accession' });
+    }
+});
 export async function getCachedDomains(accessions) {
     const db = await getDB();
     const tx = db.transaction(STORE_NAME, 'readonly');

package/dist/utils/idb.d.ts

@@ -0,0 +1,12 @@
+import type { DBSchema, IDBPDatabase, OpenDBCallbacks } from 'idb';
+/**
+ * Memoized `openDB` for a typed schema, shared by this plugin's caches.
+ *
+ * The connection promise is cached so callers share one connection, and dropped
+ * again if the open fails, so a later call retries instead of replaying the same
+ * rejection forever (IndexedDB is unavailable in some private-browsing modes).
+ *
+ * Passing a DBSchema is what keeps `get`/`getAll` from returning `any`: with an
+ * untyped database every cached record reaches the UI unchecked.
+ */
+export declare function createDbOpener<T extends DBSchema>(name: string, version: number, upgrade: OpenDBCallbacks<T>['upgrade']): () => Promise<IDBPDatabase<T>>;

package/dist/utils/idb.js

@@ -0,0 +1,21 @@
+import { openDB } from 'idb';
+/**
+ * Memoized `openDB` for a typed schema, shared by this plugin's caches.
+ *
+ * The connection promise is cached so callers share one connection, and dropped
+ * again if the open fails, so a later call retries instead of replaying the same
+ * rejection forever (IndexedDB is unavailable in some private-browsing modes).
+ *
+ * Passing a DBSchema is what keeps `get`/`getAll` from returning `any`: with an
+ * untyped database every cached record reaches the UI unchecked.
+ */
+export function createDbOpener(name, version, upgrade) {
+    let dbPromise;
+    return () => {
+        dbPromise ??= openDB(name, version, { upgrade }).catch((e) => {
+            dbPromise = undefined;
+            throw e;
+        });
+        return dbPromise;
+    };
+}

package/dist/utils/ncbiOrthologs.d.ts

@@ -0,0 +1,105 @@
+export declare const COMMON_SPECIES: readonly [{
+    readonly label: "Human";
+    readonly taxId: 9606;
+}, {
+    readonly label: "Mouse";
+    readonly taxId: 10090;
+}, {
+    readonly label: "Rat";
+    readonly taxId: 10116;
+}, {
+    readonly label: "Cow";
+    readonly taxId: 9913;
+}, {
+    readonly label: "Pig";
+    readonly taxId: 9823;
+}, {
+    readonly label: "Dog";
+    readonly taxId: 9615;
+}, {
+    readonly label: "Chicken";
+    readonly taxId: 9031;
+}, {
+    readonly label: "Frog";
+    readonly taxId: 8364;
+}, {
+    readonly label: "Zebrafish";
+    readonly taxId: 7955;
+}, {
+    readonly label: "Fruitfly";
+    readonly taxId: 7227;
+}, {
+    readonly label: "C. elegans";
+    readonly taxId: 6239;
+}, {
+    readonly label: "Yeast";
+    readonly taxId: 4932;
+}, {
+    readonly label: "Arabidopsis";
+    readonly taxId: 3702;
+}];
+export declare const COMMON_TAX_RANK: Map<number, number>;
+export interface OrthologRow {
+    taxId: number;
+    /** single-token id used identically in the FASTA, the tree and the domain GFF */
+    label: string;
+    scientificName: string;
+    commonName?: string;
+    geneId: string;
+    /** accession.version */
+    protein: string;
+    sequence: 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.
+ * Several candidate identifiers are tried in order, because a JBrowse feature
+ * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
+ * some of those are real symbols.
+ */
+export declare function resolveGeneId(candidates: string[], taxId: number): Promise<{
+    geneId: string;
+    matched: string;
+} | undefined>;
+/** One ortholog gene per species, restricted to the requested taxa. */
+export declare function fetchOrthologGenes(geneId: string, taxa: Set<number>): Promise<{
+    taxId: number;
+    geneId: string;
+    scientificName: string;
+    commonName?: string;
+}[]>;
+/**
+ * geneId -> representative protein accession: MANE Select where flagged, else
+ * the longest isoform. A stable, comparable choice across species — picking
+ * "the first" would silently vary with NCBI's ordering.
+ */
+export declare function fetchRepresentativeProteins(geneIds: string[]): Promise<Map<string, string>>;
+/** accession (first header token) -> ungapped sequence, from a multi-FASTA. */
+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.
+ */
+export declare function dedupeLabels(names: string[]): string[];
+/**
+ * The representative protein for a single gene, with its sequence. Used to
+ * decide whether the user's own translated transcript is byte-identical to the
+ * RefSeq protein — if it is, that accession's precomputed CDD domains apply to
+ * the query row exactly, and if it isn't, they would land at an offset.
+ */
+export declare function fetchProteinForGene(geneId: string): Promise<{
+    accession: string;
+    sequence: string;
+} | undefined>;
+/**
+ * The whole NCBI half of the pipeline: gene -> ortholog rows carrying labels,
+ * accessions and sequences. Everything here is a precomputed lookup, so this
+ * returns in seconds rather than the 10+ minutes a BLAST submission costs.
+ */
+export declare function fetchOrthologRows({ geneId, taxa, onProgress, }: {
+    geneId: string;
+    taxa: Set<number>;
+    onProgress: (arg: string) => void;
+}): Promise<OrthologRow[]>;

package/dist/utils/ncbiOrthologs.js

@@ -0,0 +1,211 @@
+// Homolog discovery WITHOUT a search job.
+//
+// The BLAST path answers "what looks like this sequence", which is not the
+// question an MSA row set wants — it wants "what is homologous to this gene,
+// one per species, labelled by species". BLAST then costs 10+ minutes to
+// return a redundant, accession-labelled hit list that has to be deduplicated
+// before it reads. NCBI has already computed the answer: the Datasets
+// orthologs endpoint returns one ortholog gene per species, instantly.
+//
+// gene symbol -> gene id -> orthologs -> a representative protein each ->
+// sequences, all from NCBI, in a handful of requests. The caller aligns them
+// (EBI Clustal Omega, ~10s) and overlays CDD domains, which are already baked
+// into the GenPept records (see ncbiDomains.ts).
+//
+// Mirrors jb2hubs' website/src/components/proteinMsa.ts assembler, trimmed to
+// what the launch dialog needs and using this plugin's fetch/eutils helpers.
+import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
+import { jsonfetch, textfetch } from './fetch';
+// v2, not v2alpha: the alpha path still answers /orthologs but 404s
+// /product_report, so an assembler pointed at it silently resolves zero
+// representative proteins and reports "no orthologs" for every gene.
+const DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2';
+const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+// The species panel offered in the launch dialog, ordered from the reference
+// outward so a run that finds only close relatives still reads as a ladder.
+// Orthologs absent for a given gene are skipped rather than erroring.
+export const COMMON_SPECIES = [
+    { label: 'Human', taxId: 9606 },
+    { label: 'Mouse', taxId: 10090 },
+    { label: 'Rat', taxId: 10116 },
+    { label: 'Cow', taxId: 9913 },
+    { label: 'Pig', taxId: 9823 },
+    { label: 'Dog', taxId: 9615 },
+    { label: 'Chicken', taxId: 9031 },
+    { label: 'Frog', taxId: 8364 },
+    { label: 'Zebrafish', taxId: 7955 },
+    { label: 'Fruitfly', taxId: 7227 },
+    { label: 'C. elegans', taxId: 6239 },
+    { label: 'Yeast', taxId: 4932 },
+    { label: 'Arabidopsis', taxId: 3702 },
+];
+export const COMMON_TAX_RANK = new Map(COMMON_SPECIES.map((s, i) => [s.taxId, i]));
+function ncbiUrl(url) {
+    const sep = url.includes('?') ? '&' : '?';
+    return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
+}
+/**
+ * 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.
+ * Several candidate identifiers are tried in order, because a JBrowse feature
+ * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
+ * some of those are real symbols.
+ */
+export async function resolveGeneId(candidates, taxId) {
+    for (const raw of candidates) {
+        const query = raw.trim();
+        if (!query) {
+            continue;
+        }
+        if (/^\d+$/.test(query)) {
+            return { geneId: query, matched: query };
+        }
+        // strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53)
+        const cleaned = query.replace(/^\w+:/, '').replace(/\.\d+$/, '');
+        const term = `${cleaned}[Gene Name] AND ${taxId}[taxid]`;
+        const json = await jsonfetch(ncbiUrl(`${EUTILS}/esearch.fcgi?db=gene&term=${encodeURIComponent(term)}&retmode=json&retmax=1`));
+        const geneId = json.esearchresult?.idlist?.[0];
+        if (geneId) {
+            return { geneId, matched: cleaned };
+        }
+    }
+    return undefined;
+}
+/** One ortholog gene per species, restricted to the requested taxa. */
+export async function fetchOrthologGenes(geneId, taxa) {
+    const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`));
+    const byTaxon = new Map();
+    for (const { gene } of json.reports ?? []) {
+        const taxId = Number(gene?.tax_id);
+        if (gene?.gene_id && taxa.has(taxId) && !byTaxon.has(taxId)) {
+            byTaxon.set(taxId, {
+                taxId,
+                geneId: gene.gene_id,
+                scientificName: gene.taxname ?? String(taxId),
+                commonName: gene.common_name,
+            });
+        }
+    }
+    return [...byTaxon.values()].sort((a, b) => (COMMON_TAX_RANK.get(a.taxId) ?? Infinity) -
+        (COMMON_TAX_RANK.get(b.taxId) ?? Infinity));
+}
+/**
+ * geneId -> representative protein accession: MANE Select where flagged, else
+ * the longest isoform. A stable, comparable choice across species — picking
+ * "the first" would silently vary with NCBI's ordering.
+ */
+export async function fetchRepresentativeProteins(geneIds) {
+    const byGene = new Map();
+    if (geneIds.length > 0) {
+        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneIds.join(',')}/product_report`));
+        for (const { product } of json.reports ?? []) {
+            const candidates = (product?.transcripts ?? [])
+                .map(t => ({
+                acc: t.protein?.accession_version,
+                len: t.protein?.length ?? 0,
+                mane: /select/i.test(t.select_category ?? ''),
+            }))
+                .filter((c) => !!c.acc);
+            const best = candidates.find(c => c.mane) ??
+                [...candidates].sort((a, b) => b.len - a.len).at(0);
+            if (product?.gene_id && best) {
+                byGene.set(product.gene_id, best.acc);
+            }
+        }
+    }
+    return byGene;
+}
+/** accession (first header token) -> ungapped sequence, from a multi-FASTA. */
+export function parseFasta(text) {
+    const map = new Map();
+    let acc;
+    let buf = [];
+    for (const line of text.split('\n')) {
+        if (line.startsWith('>')) {
+            if (acc) {
+                map.set(acc, buf.join(''));
+            }
+            acc = line.slice(1).split(/\s+/)[0];
+            buf = [];
+        }
+        else {
+            buf.push(line.trim());
+        }
+    }
+    if (acc) {
+        map.set(acc, buf.join(''));
+    }
+    return map;
+}
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+/**
+ * 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.
+ */
+export function dedupeLabels(names) {
+    const seen = new Map();
+    return names.map(name => {
+        const base = sanitize(name) || 'row';
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        return n === 0 ? base : `${base}_${n + 1}`;
+    });
+}
+/**
+ * The representative protein for a single gene, with its sequence. Used to
+ * decide whether the user's own translated transcript is byte-identical to the
+ * RefSeq protein — if it is, that accession's precomputed CDD domains apply to
+ * the query row exactly, and if it isn't, they would land at an offset.
+ */
+export async function fetchProteinForGene(geneId) {
+    const acc = (await fetchRepresentativeProteins([geneId])).get(geneId);
+    if (!acc) {
+        return undefined;
+    }
+    const seq = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${acc}&rettype=fasta&retmode=text`))).get(acc);
+    return seq ? { accession: acc, sequence: seq } : undefined;
+}
+/**
+ * The whole NCBI half of the pipeline: gene -> ortholog rows carrying labels,
+ * accessions and sequences. Everything here is a precomputed lookup, so this
+ * returns in seconds rather than the 10+ minutes a BLAST submission costs.
+ */
+export async function fetchOrthologRows({ geneId, taxa, onProgress, }) {
+    onProgress('Finding orthologs across species...');
+    const genes = await fetchOrthologGenes(geneId, taxa);
+    if (genes.length < 2) {
+        throw new Error(`Only ${genes.length} ortholog(s) found among the selected species — not enough to align`);
+    }
+    onProgress('Selecting a representative protein per species...');
+    const proteinByGene = await fetchRepresentativeProteins(genes.map(g => g.geneId));
+    const withProtein = genes.filter(g => proteinByGene.has(g.geneId));
+    if (withProtein.length < 2) {
+        throw new Error('Could not resolve representative proteins for the orthologs');
+    }
+    onProgress(`Fetching ${withProtein.length} protein sequences...`);
+    const accessions = withProtein.map(g => proteinByGene.get(g.geneId));
+    const seqByAcc = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${accessions.join(',')}&rettype=fasta&retmode=text`)));
+    const labels = dedupeLabels(withProtein.map(g => g.commonName ?? g.scientificName));
+    const rows = withProtein
+        .map((g, i) => {
+        const protein = proteinByGene.get(g.geneId);
+        return {
+            taxId: g.taxId,
+            label: labels[i],
+            scientificName: g.scientificName,
+            commonName: g.commonName,
+            geneId: g.geneId,
+            protein,
+            sequence: seqByAcc.get(protein) ?? '',
+        };
+    })
+        .filter(r => r.sequence);
+    if (rows.length < 2) {
+        throw new Error('Could not fetch protein sequences for the orthologs');
+    }
+    return rows;
+}

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

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

package/dist/utils/ncbiOrthologs.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'vitest';
+import { dedupeLabels, parseFasta } from './ncbiOrthologs';
+describe('dedupeLabels', () => {
+    test('sanitizes to single tokens', () => {
+        // labels are used identically as FASTA headers, Newick leaf names and GFF
+        // seq_ids, so anything that would need quoting in one of those is stripped
+        expect(dedupeLabels(['house mouse', 'Norway rat'])).toEqual([
+            'house_mouse',
+            'Norway_rat',
+        ]);
+        expect(dedupeLabels(['Frog (X. tropicalis)'])).toEqual([
+            'Frog_X_tropicalis',
+        ]);
+    });
+    test('suffixes collisions rather than overwriting a row', () => {
+        expect(dedupeLabels(['a b', 'a-b', 'a_b'])).toEqual([
+            'a_b',
+            'a_b_2',
+            'a_b_3',
+        ]);
+    });
+    test('falls back for a name with no usable characters', () => {
+        expect(dedupeLabels(['...', '...'])).toEqual(['row', 'row_2']);
+    });
+});
+describe('parseFasta', () => {
+    test('keys by the first header token and joins wrapped lines', () => {
+        const map = parseFasta(['>NP_000537.3 cellular tumor antigen p53', 'MEEP', 'QSDP', ''].join('\n'));
+        expect(map.get('NP_000537.3')).toBe('MEEPQSDP');
+    });
+    test('reads every record of a multi-FASTA', () => {
+        const map = parseFasta(['>A one', 'MMM', '>B two', 'KKK', '>C three', 'LLL'].join('\n'));
+        expect([...map.keys()]).toEqual(['A', 'B', 'C']);
+        expect(map.get('C')).toBe('LLL');
+    });
+    test('returns nothing for a response that carried no records', () => {
+        // efetch answers an unknown accession with an error body, not a 4xx, so a
+        // caller that assumed "text back = sequences" would build empty rows
+        expect(parseFasta('Error: CEFetchPApplication::proxy_stream()').size).toBe(0);
+    });
+});

package/dist/utils/taxonomyNames.js

@@ -1,23 +1,15 @@
-import { openDB } from 'idb';
 import { efetchUrl } from './eutils';
+import { textfetch } from './fetch';
+import { createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-taxonomy-cache';
 const STORE_NAME = 'common-names';
 const DB_VERSION = 2;
-let dbPromise;
-function getDB() {
-    dbPromise ??= openDB(DB_NAME, DB_VERSION, {
-        upgrade(db) {
-            if (db.objectStoreNames.contains(STORE_NAME)) {
-                db.deleteObjectStore(STORE_NAME);
-            }
-            db.createObjectStore(STORE_NAME, { keyPath: 'taxid' });
-        },
-    }).catch((e) => {
-        dbPromise = undefined;
-        throw e;
-    });
-    return dbPromise;
-}
+const getDB = createDbOpener(DB_NAME, DB_VERSION, db => {
+    if (db.objectStoreNames.contains(STORE_NAME)) {
+        db.deleteObjectStore(STORE_NAME);
+    }
+    db.createObjectStore(STORE_NAME, { keyPath: 'taxid' });
+});
 async function getCachedTaxonomies(taxids) {
     const db = await getDB();
     const tx = db.transaction(STORE_NAME, 'readonly');
@@ -59,8 +51,11 @@ export async function fetchTaxonomyInfo(taxids) {
         const batch = uncachedTaxids.slice(i, i + batchSize);
         const idsParam = batch.join(',');
         try {
-            const response = await fetch(efetchUrl({ db: 'taxonomy', id: idsParam, retmode: 'xml' }));
-            const text = await response.text();
+            // textfetch rather than a bare fetch: an NCBI 429/5xx returns an HTML
+            // error body that the regexes below silently find nothing in, so without
+            // the status check a throttled batch looks like "these taxa have no
+            // names" instead of reporting why
+            const text = await textfetch(efetchUrl({ db: 'taxonomy', id: idsParam, retmode: 'xml' }));
             // Build a map of taxid -> taxon block by finding Taxon elements.
             // Prefer entries with <LineageEx> (full top-level entries) over nested
             // entries inside another taxon's LineageEx

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.7.2";
+export declare const version = "2.7.4";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.7.2';
+export const version = '2.7.4';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.7.2",
+  "version": "2.7.4",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {
@@ -43,7 +43,7 @@
     "eslint-plugin-unicorn": "^72.0.0",
     "mobx": "^6.16.1",
     "mobx-react": "^9.2.2",
-    "msa-parsers": "^5.6.1",
+    "msa-parsers": "^5.7.1",
     "pixelmatch": "^7.2.0",
     "pngjs": "^7.0.0",
     "prettier": "^3.9.6",
@@ -51,7 +51,7 @@
     "puppeteer": "^25.3.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "react-msaview": "^5.6.3",
+    "react-msaview": "^5.7.1",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
     "serve": "^14.2.6",

package/src/AddHighlightModel/MsaToGenomeHighlight.tsx

@@ -23,14 +23,12 @@ const MsaToGenomeHighlight = observer(function MsaToGenomeHighlight2({
   // The persistent click selection always shows. The hover codon is suppressed
   // while hovering the LGV — GenomeMouseoverHighlight handles the single-bp
   // display in that case, so we don't stack a wider codon band on top of it.
-  const clickHighlight = msaView?.connectedClickHighlight
-  const hoverHighlight = hasHoverPosition(hovered)
-    ? undefined
-    : msaView?.connectedHoverHighlight
-  const highlights = [clickHighlight, hoverHighlight].filter(
-    (r): r is { refName: string; start: number; end: number } =>
-      r !== undefined,
-  )
+  const highlights = [
+    ...(msaView?.connectedClickHighlights ?? []),
+    ...(hasHoverPosition(hovered)
+      ? []
+      : (msaView?.connectedHoverHighlights ?? [])),
+  ]
 
   return highlights.length ? (
     <MsaToGenomeHighlightRenderer model={model} highlights={highlights} />

package/src/LaunchMsaView/components/LaunchMsaViewDialog.tsx

@@ -6,6 +6,7 @@ import { Tab, Tabs } from '@mui/material'
 
 import ManualMSALoader from './ManualMSALoader/ManualMSALoader'
 import NCBIBlastPanel from './NCBIBlastQuery/NCBIBlastPanel'
+import OrthologPanel from './OrthologQuery/OrthologPanel'
 import PreLoadedMSA from './PreLoadedMSA/PreLoadedMSADataPanel'
 import { readMsaDatasets } from './PreLoadedMSA/types'
 import TabPanel from './TabPanel'
@@ -25,9 +26,11 @@ export default function LaunchMsaViewDialog({
   const datasets = readMsaDatasets(session.jbrowse)
   const hasPreloadedDatasets = !!datasets?.length
 
+  // orthologs first, and the default: it answers the same question in ~10s
+  // that BLAST takes 10+ minutes to answer worse (see utils/ncbiOrthologs.ts)
   const [value, setValue] = useState<
-    'ncbi_blast' | 'preloaded_msa' | 'manual_msa'
-  >('ncbi_blast')
+    'orthologs' | 'ncbi_blast' | 'preloaded_msa' | 'manual_msa'
+  >('orthologs')
 
   return (
     <Dialog maxWidth="xl" title="Launch MSA view" open onClose={handleClose}>
@@ -37,12 +40,20 @@ export default function LaunchMsaViewDialog({
           setValue(newValue)
         }}
       >
+        <Tab label="Orthologs (fast)" value="orthologs" />
         <Tab label="NCBI BLAST query" value="ncbi_blast" />
         {hasPreloadedDatasets ? (
           <Tab label="Pre-loaded MSA datasets" value="preloaded_msa" />
         ) : null}
         <Tab label="Manual upload" value="manual_msa" />
       </Tabs>
+      <TabPanel value={value} index="orthologs">
+        <OrthologPanel
+          handleClose={handleClose}
+          feature={feature}
+          model={model}
+        />
+      </TabPanel>
       <TabPanel value={value} index="ncbi_blast">
         <NCBIBlastPanel
           handleClose={handleClose}

package/src/LaunchMsaView/components/NCBIBlastQuery/CachedBlastResults.tsx

@@ -117,7 +117,7 @@ const CachedBlastResults = observer(function ({
             }
           }}
         >
-          Clear All
+          Clear results for this gene
         </Button>
       </div>
       <List dense className={classes.resultList}>

package/src/LaunchMsaView/components/NCBIBlastQuery/useCachedBlastResults.ts

@@ -1,7 +1,6 @@
 import useSWR from 'swr'
 
 import {
-  clearAllCachedResults,
   deleteCachedResult,
   getAllCachedResults,
 } from '../../../utils/blastCache'
@@ -30,8 +29,11 @@ export function useCachedBlastResults(geneIds: string[]) {
     )
   }
 
+  // deletes only what this hook listed, i.e. the results for these gene ids.
+  // The list the user is looking at is gene-scoped, so a store-wide clear here
+  // would silently throw away every other gene's cached alignments too
   const handleClearAll = async () => {
-    await clearAllCachedResults()
+    await Promise.all((results ?? []).map(r => deleteCachedResult(r.id)))
     await mutate([], false)
   }