jbrowse-plugin-msaview 2.8.2 → 2.10.0

package/dist/utils/ncbiOrthologs.js

@@ -14,68 +14,41 @@
 //
 // 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 { NCBI_EMAIL, NCBI_TOOL, efetchPost } 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.
+// NCBI's ortholog report IS the species panel. There is no list here to keep in
+// step with what NCBI knows, and the panel widens by itself as NCBI annotates
+// more genomes.
 //
-// The index order is the order the sequences are SUBMITTED in
-// (`COMMON_TAX_RANK` below sorts `fetchOrthologGenes`' return), not the order the
-// rows are drawn in: the view lays rows out by the guide tree the aligner returns,
-// so a run on this list comes out grouped by relatedness rather than by this
-// list's own sequence. Reordering here changes what Clustal is handed, not the
-// picture.
+// It used to be a hand-written 23-species list intersected with the report, and
+// the intersection is what made the alignment thin: NCBI publishes 165 orthologs
+// for human NLRP1 and 865 for CFTR, so the list kept 12 of the first and 19 of
+// the second. It also carried four species -- fruitfly, yeast, C. elegans and
+// arabidopsis -- that the endpoint has never once returned for a human gene:
+// checked against NLRP1, TP53, ACTB, BRCA1, PIK3CA, APOE and NOTCH1, whose fly
+// ortholog is famous and still absent. NCBI's ortholog sets are vertebrate
+// scoped.
 //
-// THE MAMMALS EARN THEIR PLACE, and the reason is measured rather than aesthetic.
-// The thirteen this list used to hold were one per major clade, which reads well
-// on a gene conserved to yeast and produces almost nothing on a gene that is not:
-// NCBI publishes 165 orthologs for human NLRP1 and every one of them is a mammal,
-// so of the old thirteen only Human, Mouse, Cow, Pig and Dog returned a row --
-// five, and Rat not among them, since NLRP1 is absent in Rattus norvegicus. The
-// same query against this list returns twelve. An inflammasome gene is not an
-// unusual case; anything immune, reproductive or lineage-specific behaves the
-// same way, and those are the genes a person opens an ortholog alignment on.
+// The report's OWN order is the ladder the list was hand-built to approximate,
+// and it is per gene. CFTR opens human, mouse, rat, zebrafish, pig, sheep,
+// rabbit, chicken, cattle, ferret, dog, rhesus; NLRP1, which has no ortholog
+// outside placental mammals, opens human, mouse, rhesus, shrew mouse, chimp,
+// dog, cattle, horse. So `limit` takes a prefix and never needs a rank table.
 //
-// Cat, rabbit and opossum are here despite contributing nothing to that gene.
-// They are the three that most often separate "absent in this clade" from
-// "absent in this species", which is the question a gap in the alignment raises.
+// The rows are SUBMITTED in that order, not drawn in it -- the view lays rows out
+// by the guide tree the aligner returns.
 //
-// The cost is the run, and it is roughly linear: one NCBI protein fetch per
-// species and a Clustal Omega job over what comes back, so ~23 rows is about
-// twice the ~13-row wait. Still seconds rather than the minutes BLAST takes,
-// which is the comparison the panel's own text makes.
-export const COMMON_SPECIES = [
-    { label: 'Human', taxId: 9606 },
-    { label: 'Chimpanzee', taxId: 9598 },
-    { label: 'Gorilla', taxId: 9595 },
-    { label: 'Rhesus macaque', taxId: 9544 },
-    { label: 'Marmoset', taxId: 9483 },
-    { label: 'Mouse', taxId: 10090 },
-    { label: 'Rat', taxId: 10116 },
-    { label: 'Guinea pig', taxId: 10141 },
-    { label: 'Rabbit', taxId: 9986 },
-    { label: 'Cat', taxId: 9685 },
-    { label: 'Dog', taxId: 9615 },
-    { label: 'Horse', taxId: 9796 },
-    { label: 'Pig', taxId: 9823 },
-    { label: 'Cow', taxId: 9913 },
-    { label: 'Sheep', taxId: 9940 },
-    { label: 'Opossum', taxId: 13616 },
-    { 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]));
+// What limits the row count is the aligner, and it is linear in rows at roughly
+// half a second each for a ~1400aa protein: 165 NLRP1 orthologs align at EBI in
+// 88s, 865 CFTR orthologs in 407s. `defaultMaxSpecies` keeps a default run under
+// a minute; EBI's own ceiling is 4000 sequences and 4MB, which even CFTR's full
+// set (1.3MB) sits inside.
+export const defaultMaxSpecies = 100;
 function ncbiUrl(url) {
     const sep = url.includes('?') ? '&' : '?';
     return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
@@ -107,13 +80,22 @@ export async function resolveGeneId(candidates, taxId) {
     }
     return undefined;
 }
-/** One ortholog gene per species, restricted to the requested taxa. */
-export async function fetchOrthologGenes(geneId, taxa) {
+/**
+ * One ortholog gene per species, in NCBI's report order, capped at `limit`.
+ *
+ * `taxa` narrows the set when a caller wants specific species; omitted, every
+ * species NCBI has an ortholog for is a candidate. `exclude` drops the query
+ * taxon, which the QUERY row already represents.
+ */
+export async function fetchOrthologGenes(geneId, { taxa, exclude, limit = defaultMaxSpecies, } = {}) {
     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)) {
+        if (gene?.gene_id &&
+            taxId !== exclude &&
+            (taxa?.has(taxId) ?? true) &&
+            !byTaxon.has(taxId)) {
             byTaxon.set(taxId, {
                 taxId,
                 geneId: gene.gene_id,
@@ -121,10 +103,26 @@ export async function fetchOrthologGenes(geneId, taxa) {
                 commonName: gene.common_name,
             });
         }
+        if (byTaxon.size >= limit) {
+            break;
+        }
     }
-    return [...byTaxon.values()].sort((a, b) => (COMMON_TAX_RANK.get(a.taxId) ?? Infinity) -
-        (COMMON_TAX_RANK.get(b.taxId) ?? Infinity));
+    return [...byTaxon.values()];
 }
+// Two ceilings sit between a gene id list and its product report, and both fail
+// by returning less rather than by erroring, so a caller that ignores them just
+// draws a thinner alignment.
+//
+// The ids go in the URL PATH, and NCBI answers HTTP 414 above roughly 8KB of
+// them -- CFTR's 865 orthologs join to 8609 characters and 414 on the nose.
+// `PRODUCT_REPORT_CHUNK` keeps a request well inside that.
+//
+// Then the endpoint paginates at 20 with the count in `total_count` and the rest
+// behind `next_page_token`, which is invisible to a caller reading `reports`.
+// `page_size` covers a chunk in one request. The old 23-species panel never
+// reached this: the query taxon is excluded and NCBI has no ortholog for the
+// four invertebrate entries, so its ceiling was 19.
+const PRODUCT_REPORT_CHUNK = 150;
 /**
  * geneId -> representative protein accession: MANE Select where flagged, else
  * the longest isoform. A stable, comparable choice across species — picking
@@ -132,8 +130,9 @@ export async function fetchOrthologGenes(geneId, taxa) {
  */
 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 (let i = 0; i < geneIds.length; i += PRODUCT_REPORT_CHUNK) {
+        const chunk = geneIds.slice(i, i + PRODUCT_REPORT_CHUNK);
+        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${chunk.join(',')}/product_report?page_size=${chunk.length}`));
         for (const { product } of json.reports ?? []) {
             const candidates = (product?.transcripts ?? [])
                 .map(t => ({
@@ -210,11 +209,11 @@ export async function fetchProteinForGene(geneId) {
  * 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, }) {
+export async function fetchOrthologRows({ geneId, taxa, exclude, limit, onProgress, }) {
     onProgress('Finding orthologs across species...');
-    const genes = await fetchOrthologGenes(geneId, taxa);
+    const genes = await fetchOrthologGenes(geneId, { taxa, exclude, limit });
     if (genes.length < 2) {
-        throw new Error(`Only ${genes.length} ortholog(s) found among the selected species — not enough to align`);
+        throw new Error(`Only ${genes.length} ortholog(s) found for this gene — not enough to align`);
     }
     onProgress('Selecting a representative protein per species...');
     const proteinByGene = await fetchRepresentativeProteins(genes.map(g => g.geneId));
@@ -224,7 +223,12 @@ export async function fetchOrthologRows({ geneId, taxa, onProgress, }) {
     }
     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 seqByAcc = parseFasta(await textfetch(...efetchPost({
+        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) => {

package/dist/utils/ncbiOrthologs.test.js

@@ -1,5 +1,5 @@
-import { describe, expect, test } from 'vitest';
-import { dedupeLabels, parseFasta } from './ncbiOrthologs';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, } from './ncbiOrthologs';
 describe('dedupeLabels', () => {
     test('sanitizes to single tokens', () => {
         // labels are used identically as FASTA headers, Newick leaf names and GFF
@@ -39,3 +39,83 @@ describe('parseFasta', () => {
         expect(parseFasta('Error: CEFetchPApplication::proxy_stream()').size).toBe(0);
     });
 });
+// The two ceilings that make a widened species set silently return fewer rows.
+// Both are shaped like a successful response, so only a test that counts what
+// came back sees them.
+describe('the NCBI request ceilings', () => {
+    const stubFetch = (handler) => {
+        const seen = [];
+        vi.stubGlobal('fetch', (url) => {
+            seen.push(url);
+            return Promise.resolve({
+                ok: true,
+                status: 200,
+                json: () => Promise.resolve(handler(url)),
+                text: () => Promise.resolve(JSON.stringify(handler(url))),
+            });
+        });
+        return seen;
+    };
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    const orthologReport = (n) => ({
+        total_count: n,
+        reports: Array.from({ length: n }, (_, i) => ({
+            gene: {
+                gene_id: String(1000 + i),
+                tax_id: String(2000 + i),
+                taxname: `Species ${i}`,
+            },
+        })),
+    });
+    test('fetchOrthologGenes takes a prefix of NCBI report order, not a filtered intersection', async () => {
+        stubFetch(() => orthologReport(165));
+        const genes = await fetchOrthologGenes('22861', { limit: 10 });
+        expect(genes.length).toBe(10);
+        // the report's own order, which leads with the reference organisms
+        expect(genes.map(g => g.geneId)).toEqual(Array.from({ length: 10 }, (_, i) => String(1000 + i)));
+    });
+    test('fetchOrthologGenes drops the query taxon without spending a row on it', async () => {
+        stubFetch(() => orthologReport(165));
+        const genes = await fetchOrthologGenes('22861', { exclude: 2000, limit: 3 });
+        expect(genes.map(g => g.taxId)).toEqual([2001, 2002, 2003]);
+    });
+    test('fetchRepresentativeProteins chunks the gene ids below the URI length NCBI 414s at', async () => {
+        // 865 CFTR ortholog gene ids join to 8609 characters, which NCBI answers
+        // with HTTP 414 rather than a short result
+        const ids = Array.from({ length: 400 }, (_, i) => String(100000 + i));
+        const seen = stubFetch(url => ({
+            reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '').split(',').map(id => ({
+                product: {
+                    gene_id: id,
+                    transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+                },
+            })),
+        }));
+        const byGene = await fetchRepresentativeProteins(ids);
+        expect(byGene.size).toBe(400);
+        expect(seen.length).toBeGreaterThan(1);
+        expect(Math.max(...seen.map(u => u.length))).toBeLessThan(8000);
+    });
+    test('fetchRepresentativeProteins asks for a page big enough to hold its chunk', async () => {
+        // the endpoint paginates at 20 by default and hides the rest behind
+        // next_page_token, so a caller reading only `reports` loses everything past
+        // the first page and reports no protein for those genes
+        const ids = Array.from({ length: 50 }, (_, i) => String(100000 + i));
+        const seen = stubFetch(url => ({
+            reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '')
+                .split(',')
+                .slice(0, Number(/page_size=(\d+)/.exec(url)?.[1] ?? 20))
+                .map(id => ({
+                product: {
+                    gene_id: id,
+                    transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+                },
+            })),
+        }));
+        const byGene = await fetchRepresentativeProteins(ids);
+        expect(byGene.size).toBe(50);
+        expect(seen.every(u => /page_size=\d+/.test(u))).toBe(true);
+    });
+});

package/dist/utils/ncbiTaxonomy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Free text -> NCBI taxon id. A bare number is taken as the id itself; anything
+ * else is searched against db=taxonomy, which resolves a scientific name
+ * (`Danio rerio`), a common name (`zebrafish`) and a genus alike.
+ *
+ * This replaces a fixed list of species the dialog used to offer. The query
+ * taxon has to match the assembly the user is browsing -- `resolveGeneId`
+ * searches `SYMBOL[Gene Name] AND <taxid>[taxid]` -- so a list that stops at 23
+ * species silently resolves the wrong organism's gene for anyone outside it.
+ */
+export declare function resolveTaxId(query: string): Promise<number | undefined>;

package/dist/utils/ncbiTaxonomy.js

@@ -0,0 +1,33 @@
+import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
+import { jsonfetch } from './fetch';
+const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+/**
+ * Free text -> NCBI taxon id. A bare number is taken as the id itself; anything
+ * else is searched against db=taxonomy, which resolves a scientific name
+ * (`Danio rerio`), a common name (`zebrafish`) and a genus alike.
+ *
+ * This replaces a fixed list of species the dialog used to offer. The query
+ * taxon has to match the assembly the user is browsing -- `resolveGeneId`
+ * searches `SYMBOL[Gene Name] AND <taxid>[taxid]` -- so a list that stops at 23
+ * species silently resolves the wrong organism's gene for anyone outside it.
+ */
+export async function resolveTaxId(query) {
+    const term = query.trim();
+    if (!term) {
+        return undefined;
+    }
+    if (/^\d+$/.test(term)) {
+        return Number(term);
+    }
+    const search = new URLSearchParams({
+        db: 'taxonomy',
+        term,
+        retmode: 'json',
+        retmax: '1',
+        tool: NCBI_TOOL,
+        email: NCBI_EMAIL,
+    });
+    const json = await jsonfetch(`${EUTILS}/esearch.fcgi?${search.toString()}`);
+    const id = json.esearchresult?.idlist?.[0];
+    return id ? Number(id) : undefined;
+}

package/dist/utils/types.d.ts

@@ -5,19 +5,14 @@ export interface BlastHitDescription {
     taxid?: number;
     title?: string;
 }
-export interface BlastResults {
-    BlastOutput2: {
-        report: {
-            results: {
-                search: {
-                    hits: {
-                        description: BlastHitDescription[];
-                        hsps: {
-                            hseq: string;
-                        }[];
-                    }[];
-                };
-            };
-        };
+/**
+ * The shape utils/ebiBlast.ts normalizes EBI's hits into. It keeps the field
+ * names NCBI's JSON2 used, so everything downstream of the search — row naming,
+ * taxonomy lookup, the MSA — was left untouched when the backend moved.
+ */
+export interface BlastHit {
+    description: BlastHitDescription[];
+    hsps: {
+        hseq: string;
     }[];
 }

package/dist/utils/useLocalStorage.d.ts

@@ -1 +1,2 @@
+export declare function readLocalStorage<T>(key: string, initialValue: T): T;
 export declare function useLocalStorage<T>(key: string, initialValue: T): readonly [T, (value: T) => void];

package/dist/utils/useLocalStorage.js

@@ -4,7 +4,7 @@ import { useState } from 'react';
 // throw "(0, PR.useLocalStorage) is not a function" on hosts built during that
 // window. Same failure mode as `defaultCodonTable`; keeping our own copy takes
 // this plugin out of the whack-a-mole.
-function readLocalStorage(key, initialValue) {
+export function readLocalStorage(key, initialValue) {
     try {
         const item = globalThis.localStorage.getItem(key);
         return item === null ? initialValue : JSON.parse(item);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.8.2";
+export declare const version = "2.10.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.8.2';
+export const version = '2.10.0';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.8.2",
+  "version": "2.10.0",
   "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.7.1",
+    "msa-parsers": "^5.9.0",
     "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.7.2",
+    "react-msaview": "^5.9.0",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
     "serve": "^14.2.6",

package/src/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastAutomaticPanel.tsx → BlastQuery/BlastAutomaticPanel.tsx}

@@ -14,7 +14,7 @@ import { makeStyles } from 'tss-react/mui'
 import CachedBlastResults from './CachedBlastResults'
 import MsaAlgorithmSelect from './MsaAlgorithmSelect'
 import { blastLaunchView } from './blastLaunchView'
-import { blastDatabaseOptions, blastPrograms } from './consts'
+import { blastDatabaseOptions, defaultBlastDatabase } from './consts'
 import { useCachedBlastResults } from './useCachedBlastResults'
 import TextField2 from '../../../components/TextField2'
 import {
@@ -27,20 +27,13 @@ import SubmitCancelActions from '../SubmitCancelActions'
 import TranscriptSelector from '../TranscriptSelector'
 import { useTranscriptSelection } from '../useTranscriptSelection'
 
-import type { BlastDatabase, BlastProgram, MsaAlgorithm } from './consts'
+import type { BlastDatabase, MsaAlgorithm } from './consts'
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util'
 
 const useStyles = makeStyles()({
   selectField: {
     width: 150,
   },
-  databaseFieldContainer: {
-    display: 'flex',
-  },
-  clusterSeqMessage: {
-    marginLeft: 4,
-    alignContent: 'center',
-  },
   cachedResultsAccordion: {
     marginTop: 20,
   },
@@ -49,16 +42,14 @@ const useStyles = makeStyles()({
   },
 })
 
-const NCBIBlastAutomaticPanel = observer(function ({
+const BlastAutomaticPanel = observer(function ({
   handleClose,
   feature,
   model,
   children,
-  baseUrl,
 }: {
   model: AbstractTrackModel
   feature: Feature
-  baseUrl: string
   handleClose: () => void
   children: React.ReactNode
 }) {
@@ -66,11 +57,9 @@ const NCBIBlastAutomaticPanel = observer(function ({
   const view = getLinearGenomeView(model)
   const [launchViewError, setLaunchViewError] = useState<unknown>()
   const [selectedBlastDatabase, setSelectedBlastDatabase] =
-    useState<BlastDatabase>('nr')
+    useState<BlastDatabase>(defaultBlastDatabase)
   const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] =
     useState<MsaAlgorithm>('clustalo')
-  const [selectedBlastProgram, setSelectedBlastProgram] =
-    useState<BlastProgram>('quick-blastp')
 
   const geneIds = useMemo(() => getGeneIdentifiers(feature), [feature])
   const { results: cachedResults, error: cachedResultsError } =
@@ -90,11 +79,7 @@ const NCBIBlastAutomaticPanel = observer(function ({
           select
           value={selectedBlastDatabase}
           onChange={event => {
-            const newDb = event.target.value as BlastDatabase
-            setSelectedBlastDatabase(newDb)
-            if (newDb === 'nr_cluster_seq') {
-              setSelectedBlastProgram('blastp')
-            }
+            setSelectedBlastDatabase(event.target.value as BlastDatabase)
           }}
         >
           {blastDatabaseOptions.map(val => (
@@ -110,45 +95,16 @@ const NCBIBlastAutomaticPanel = observer(function ({
           onChange={setSelectedMsaAlgorithm}
         />
 
-        <div className={classes.databaseFieldContainer}>
-          <TextField2
-            variant="outlined"
-            label="BLAST program"
-            disabled={selectedBlastDatabase === 'nr_cluster_seq'}
-            className={classes.selectField}
-            select
-            value={selectedBlastProgram}
-            onChange={event => {
-              setSelectedBlastProgram(event.target.value as BlastProgram)
-            }}
-          >
-            {blastPrograms.map(val => (
-              <MenuItem value={val} key={val}>
-                {val}
-              </MenuItem>
-            ))}
-          </TextField2>
-          {selectedBlastDatabase === 'nr_cluster_seq' ? (
-            <Typography
-              variant="subtitle2"
-              className={classes.clusterSeqMessage}
-            >
-              Can only use blastp on nr_cluster_seq
-            </Typography>
-          ) : null}
-        </div>
-
         <TranscriptSelector feature={feature} {...transcriptSelection} />
 
         <Typography className={classes.infoText}>
-          This panel will automatically submit a query to NCBI. Using blastp can
-          take 10+ minutes to run, quick-blastp is generally a lot faster but is
-          not available for the clustered database. After completion, all the
-          hits will be run through a multiple sequence alignment. Note: we are
-          not able to currently run NCBI COBALT automatically on the BLAST
-          results, even though that is the method NCBI uses on their website. If
-          you need a COBALT alignment, please use the manual approach of
-          submitting BLAST yourself and downloading the resulting files
+          This panel will automatically submit a blastp query to EBI, which
+          searches UniProtKB. Searches usually finish in under a minute, and
+          swissprot returns curated sequences that align more cleanly than the
+          many near-identical entries a TrEMBL search brings back. After
+          completion, all the hits will be run through a multiple sequence
+          alignment. Searching NCBI's nr needs the manual approach: NCBI no
+          longer lets a browser read responses from Blast.cgi.
         </Typography>
 
         {cachedResults.length > 0 ? (
@@ -177,8 +133,6 @@ const NCBIBlastAutomaticPanel = observer(function ({
                 view,
                 newViewTitle: getBlastViewTitle(feature, selectedTranscript),
                 blastParams: {
-                  baseUrl,
-                  blastProgram: selectedBlastProgram,
                   blastDatabase: selectedBlastDatabase,
                   msaAlgorithm: selectedMsaAlgorithm,
                   selectedTranscript,
@@ -198,4 +152,4 @@ const NCBIBlastAutomaticPanel = observer(function ({
   )
 })
 
-export default NCBIBlastAutomaticPanel
+export default BlastAutomaticPanel

package/src/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastManualPanel.tsx → BlastQuery/BlastManualPanel.tsx}

@@ -5,6 +5,7 @@ import { Button, DialogActions, Typography } from '@mui/material'
 import { observer } from 'mobx-react'
 import { makeStyles } from 'tss-react/mui'
 
+import { BASE_BLAST_URL } from './consts'
 import ExternalLink from '../../../components/ExternalLink'
 import { cleanProteinSequence, getLinearGenomeView } from '../../util'
 import LaunchPanelContent from '../LaunchPanelContent'
@@ -24,17 +25,15 @@ const useStyles = makeStyles()({
   },
 })
 
-const NCBIBlastManualPanel = observer(function ({
+const BlastManualPanel = observer(function ({
   handleClose,
   feature,
   model,
   children,
-  baseUrl,
 }: {
   children: React.ReactNode
   model: AbstractTrackModel
   feature: Feature
-  baseUrl: string
   handleClose: () => void
 }) {
   const { classes } = useStyles()
@@ -43,8 +42,10 @@ const NCBIBlastManualPanel = observer(function ({
   const { proteinSequence, error } = transcriptSelection
 
   const s2 = cleanProteinSequence(proteinSequence)
-  const link = `${baseUrl}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${s2}`
-  const link2 = `${baseUrl}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${shorten2(s2, 10)}`
+  // a link the user follows to NCBI's own site, not something we fetch — which
+  // is exactly why this route still works when the automatic one cannot
+  const link = `${BASE_BLAST_URL}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${s2}`
+  const link2 = `${BASE_BLAST_URL}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${shorten2(s2, 10)}`
 
   return (
     <>
@@ -83,4 +84,4 @@ const NCBIBlastManualPanel = observer(function ({
   )
 })
 
-export default NCBIBlastManualPanel
+export default BlastManualPanel

package/src/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastMethodSelector.tsx → BlastQuery/BlastMethodSelector.tsx}

@@ -2,9 +2,9 @@ import React from 'react'
 
 import { FormControl, FormControlLabel, Radio, RadioGroup } from '@mui/material'
 
-import type { BlastLookupMethod } from './NCBIBlastPanel'
+import type { BlastLookupMethod } from './BlastPanel'
 
-export default function NCBIBlastMethodSelector({
+export default function BlastMethodSelector({
   lookupMethod,
   setLookupMethod,
 }: {
@@ -25,11 +25,6 @@ export default function NCBIBlastMethodSelector({
           control={<Radio />}
           label="Automatic"
         />
-        <FormControlLabel
-          value="rid"
-          control={<Radio />}
-          label="Load from RID"
-        />
         <FormControlLabel value="manual" control={<Radio />} label="Manual" />
       </RadioGroup>
     </FormControl>