jbrowse-plugin-msaview 2.8.2 → 2.9.0

package/dist/utils/blastCache.d.ts

@@ -1,9 +1,14 @@
-import type { BlastDatabase, BlastProgram, MsaAlgorithm } from '../LaunchMsaView/components/NCBIBlastQuery/consts';
+import type { BlastDatabase, MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
 export interface CachedBlastResult {
     id: string;
     proteinSequence: string;
     blastDatabase: BlastDatabase;
-    blastProgram: BlastProgram;
+    /**
+     * 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;
     msa: string;
     tree: string;
@@ -15,10 +20,9 @@ export interface CachedBlastResult {
     transcriptName?: string;
     geneName?: string;
 }
-export declare function saveBlastResult({ proteinSequence, blastDatabase, blastProgram, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
+export declare function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
     proteinSequence: string;
     blastDatabase: BlastDatabase;
-    blastProgram: BlastProgram;
     msaAlgorithm: MsaAlgorithm;
     msa: string;
     tree: string;

package/dist/utils/blastCache.js

@@ -10,21 +10,20 @@ const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
         db.createObjectStore(STORE_NAME, { keyPath: 'id' });
     }
 });
-function createCacheKey(proteinSequence, blastDatabase, blastProgram, msaAlgorithm, transcriptId) {
+function createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId) {
     const idPart = transcriptId ? `:${transcriptId}` : '';
     // 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}:${blastProgram}:${msaAlgorithm}${idPart}:${proteinSequence}`;
+    return `${blastDatabase}:${msaAlgorithm}${idPart}:${proteinSequence}`;
 }
-export async function saveBlastResult({ proteinSequence, blastDatabase, blastProgram, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
+export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
     const db = await getDB();
-    const id = createCacheKey(proteinSequence, blastDatabase, blastProgram, msaAlgorithm, transcriptId);
+    const id = createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId);
     const entry = {
         id,
         proteinSequence,
         blastDatabase,
-        blastProgram,
         msaAlgorithm,
         msa,
         tree,

package/dist/utils/ebiBlast.d.ts

@@ -0,0 +1,52 @@
+import type { BlastHit } from './types';
+import type { BlastDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
+/**
+ * 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
+ * string); only what the MSA rows are built from is typed here.
+ */
+interface EbiBlastJson {
+    hits?: {
+        hit_acc?: string;
+        hit_id?: string;
+        hit_desc?: string;
+        /** the UniProt fields are absent on hits from non-UniProt databases */
+        hit_os?: string;
+        hit_uni_de?: string;
+        hit_uni_os?: string;
+        /** NCBI taxon id, delivered as a string */
+        hit_uni_ox?: string;
+        hit_hsps?: {
+            hsp_hseq?: string;
+        }[];
+    }[];
+}
+/**
+ * Map EBI's hit shape onto the normalized one. Exported for testing against a
+ * captured response — the field names are the whole risk here, and nothing else
+ * in CI would notice if EBI renamed one.
+ */
+export declare function normalizeEbiBlastHits(result: EbiBlastJson): BlastHit[];
+/**
+ * Human-facing link to a job, shown while it runs and on error — so it has to
+ * be EBI's own results UI, not the REST result endpoint, which does not exist
+ * yet at the moment the link is on screen.
+ */
+export declare function ebiBlastResultUrl(jobId: string): string;
+export declare function queryEbiBlastFromJobId({ jobId, onProgress, }: {
+    jobId: string;
+    onProgress: (arg: string) => void;
+}): Promise<{
+    rid: string;
+    hits: BlastHit[];
+}>;
+export declare function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }: {
+    query: string;
+    blastDatabase: BlastDatabase;
+    onProgress: (arg: string) => void;
+    onRid: (arg: string) => void;
+}): Promise<{
+    rid: string;
+    hits: BlastHit[];
+}>;
+export {};

package/dist/utils/ebiBlast.js

@@ -0,0 +1,63 @@
+import { fetchEbiResult, submitEbiJob, waitForEbiJob } from './ebiJobDispatcher';
+const TOOL = 'ncbiblast';
+/**
+ * Map EBI's hit shape onto the normalized one. Exported for testing against a
+ * captured response — the field names are the whole risk here, and nothing else
+ * in CI would notice if EBI renamed one.
+ */
+export function normalizeEbiBlastHits(result) {
+    return (result.hits ?? []).map(hit => {
+        const taxid = Number.parseInt(hit.hit_uni_ox ?? '', 10);
+        return {
+            description: [
+                {
+                    accession: hit.hit_acc ?? 'unknown',
+                    id: hit.hit_id ?? hit.hit_acc ?? 'unknown',
+                    sciname: hit.hit_uni_os ?? hit.hit_os ?? 'unknown',
+                    taxid: Number.isNaN(taxid) ? undefined : taxid,
+                    // hit_uni_de is the bare protein name; hit_desc repeats it with the
+                    // OS=/OX=/GN= suffix that makeId already covers with real columns
+                    title: hit.hit_uni_de ?? hit.hit_desc,
+                },
+            ],
+            hsps: (hit.hit_hsps ?? []).flatMap(hsp => hsp.hsp_hseq ? [{ hseq: hsp.hsp_hseq }] : []),
+        };
+    });
+}
+/**
+ * Human-facing link to a job, shown while it runs and on error — so it has to
+ * be EBI's own results UI, not the REST result endpoint, which does not exist
+ * yet at the moment the link is on screen.
+ */
+export function ebiBlastResultUrl(jobId) {
+    return `https://www.ebi.ac.uk/jdispatcher/sss/${TOOL}/summary?jobId=${jobId}`;
+}
+export async function queryEbiBlastFromJobId({ jobId, onProgress, }) {
+    onProgress(`Checking BLAST status for job: ${jobId}...`);
+    await waitForEbiJob({
+        tool: TOOL,
+        jobId,
+        onCountdown: s => {
+            onProgress(`Re-checking BLAST status in... ${s}`);
+        },
+    });
+    const hits = normalizeEbiBlastHits(JSON.parse(await fetchEbiResult({ tool: TOOL, jobId, type: 'json' })));
+    if (hits.length === 0) {
+        throw new Error('No hits found');
+    }
+    return { rid: jobId, hits };
+}
+export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }) {
+    onProgress('Submitting to EBI BLAST...');
+    const jobId = await submitEbiJob({
+        tool: TOOL,
+        params: {
+            program: 'blastp',
+            stype: 'protein',
+            database: blastDatabase,
+            sequence: query,
+        },
+    });
+    onRid(jobId);
+    return queryEbiBlastFromJobId({ jobId, onProgress });
+}

package/dist/utils/ebiJobDispatcher.d.ts

@@ -0,0 +1,33 @@
+/**
+ * EBI's Job Dispatcher REST services (clustalo, muscle, ncbiblast, ...) all
+ * speak the same run/status/result protocol, so the transport lives here and
+ * each tool only supplies its own parameters and result types.
+ *
+ * Unlike NCBI's Blast.cgi these endpoints send `Access-Control-Allow-Origin: *`,
+ * which is why the BLAST backend moved here — see docs/blast.md.
+ */
+export declare const EBI_BASE = "https://www.ebi.ac.uk/Tools/services/rest";
+/**
+ * EBI asks for a contact address on every submission so they can reach whoever
+ * is generating the load. A deployment that sends real volume should point this
+ * at its own maintainer via the BLAST settings dialog — otherwise every
+ * msaview job in the world is attributed to one person.
+ */
+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, }: {
+    tool: string;
+    params: Record<string, string>;
+}): Promise<string>;
+export declare function waitForEbiJob({ tool, jobId, intervalSeconds, onCountdown, }: {
+    tool: string;
+    jobId: string;
+    intervalSeconds?: number;
+    onCountdown: (secondsRemaining: number) => void;
+}): Promise<void>;
+export declare function fetchEbiResult({ tool, jobId, type, }: {
+    tool: string;
+    jobId: string;
+    type: string;
+}): Promise<string>;

package/dist/utils/ebiJobDispatcher.js

@@ -0,0 +1,55 @@
+import { textfetch } from './fetch';
+import { pollLoop } from './poll';
+import { readLocalStorage } from './useLocalStorage';
+/**
+ * EBI's Job Dispatcher REST services (clustalo, muscle, ncbiblast, ...) all
+ * speak the same run/status/result protocol, so the transport lives here and
+ * each tool only supplies its own parameters and result types.
+ *
+ * Unlike NCBI's Blast.cgi these endpoints send `Access-Control-Allow-Origin: *`,
+ * which is why the BLAST backend moved here — see docs/blast.md.
+ */
+export const EBI_BASE = 'https://www.ebi.ac.uk/Tools/services/rest';
+/**
+ * EBI asks for a contact address on every submission so they can reach whoever
+ * is generating the load. A deployment that sends real volume should point this
+ * at its own maintainer via the BLAST settings dialog — otherwise every
+ * msaview job in the world is attributed to one person.
+ */
+export const EBI_EMAIL_STORAGE_KEY = 'msa-ebiContactEmail';
+export const DEFAULT_EBI_EMAIL = 'colin.diesh@gmail.com';
+export function getEbiEmail() {
+    const configured = readLocalStorage(EBI_EMAIL_STORAGE_KEY, DEFAULT_EBI_EMAIL).trim();
+    return configured || DEFAULT_EBI_EMAIL;
+}
+/** 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, }) {
+    const jobId = await textfetch(`${EBI_BASE}/${tool}/run`, {
+        method: 'POST',
+        body: new URLSearchParams({ email: getEbiEmail(), ...params }),
+    });
+    return jobId.trim();
+}
+export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, }) {
+    await pollLoop({
+        intervalSeconds,
+        onCountdown,
+        check: async () => {
+            // exact match, not includes(): a job whose status is ERROR must not be
+            // able to poll forever waiting for a FINISHED that will never arrive
+            const status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim();
+            if (status === 'FINISHED') {
+                return true;
+            }
+            if (FAILED_STATUSES.has(status)) {
+                throw new Error(`EBI ${tool} job ${jobId} returned status ${status}`);
+            }
+            // RUNNING, QUEUED, PENDING and anything else EBI adds later
+            return false;
+        },
+    });
+}
+export async function fetchEbiResult({ tool, jobId, type, }) {
+    return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`);
+}

package/dist/utils/fetch.js

@@ -1,5 +1,28 @@
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        // a relative url, e.g. a same-origin proxy path
+        return url;
+    }
+}
 export async function handleFetch(url, args) {
-    const response = await fetch(url, args);
+    let response;
+    try {
+        response = await fetch(url, args);
+    }
+    catch (e) {
+        // fetch rejects with a bare "TypeError: Failed to fetch" for every network
+        // level failure, including a cross-origin response the browser refused to
+        // hand over. That is not a hypothetical: NCBI's Blast.cgi stopped sending
+        // Access-Control-Allow-Origin to third-party origins, and the raw TypeError
+        // told users nothing at all about why. See docs/blast.md.
+        if (e instanceof TypeError) {
+            throw new Error(`Could not reach ${hostOf(url)} — the request failed at the network level. This is usually a CORS restriction (the server refused to let this site read the response), an offline connection, or a blocked request.`, { cause: e });
+        }
+        throw e;
+    }
     if (!response.ok) {
         throw new Error(`HTTP ${response.status} fetching ${url} ${await response.text()}`);
     }

package/dist/utils/msa.d.ts

@@ -1,4 +1,4 @@
-import type { MsaAlgorithm } from '../LaunchMsaView/components/NCBIBlastQuery/consts';
+import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
 export declare function launchMSA({ algorithm, sequence, onProgress, }: {
     algorithm: MsaAlgorithm;
     sequence: string;

package/dist/utils/msa.js

@@ -1,57 +1,50 @@
-import { textfetch } from './fetch';
-import { pollLoop } from './poll';
-const base = `https://www.ebi.ac.uk/Tools/services/rest`;
-const email = 'colin.diesh@gmail.com';
+import { fetchEbiResult, submitEbiJob, waitForEbiJob } from './ebiJobDispatcher';
 const algorithms = {
     clustalo: {
-        params: { email },
+        params: {},
         msaResult: 'aln-clustal_num',
         treeResult: 'phylotree',
     },
     muscle: {
-        params: { email, format: 'clw', tree: 'tree1' },
+        params: { format: 'clw', tree: 'tree1' },
         msaResult: 'fa',
         treeResult: 'phylotree',
     },
     kalign: {
-        params: { email, stype: 'protein' },
+        params: { stype: 'protein' },
         msaResult: 'fa',
         treeResult: 'phylotree',
     },
     mafft: {
-        params: { email, stype: 'protein' },
+        params: { stype: 'protein' },
         msaResult: 'fa',
         treeResult: 'phylotree',
     },
 };
-async function wait({ onProgress, jobId, algorithm, }) {
-    await pollLoop({
-        intervalSeconds: 10,
-        onCountdown: s => {
-            onProgress(`Re-checking MSA status in... ${s}`);
-        },
-        check: async () => {
-            const result = await textfetch(`${base}/${algorithm}/status/${jobId}`);
-            if (result.includes('FINISHED')) {
-                return true;
-            }
-            if (result.includes('FAILURE')) {
-                throw new Error(`Failed to run: jobId ${jobId}`);
-            }
-            return false;
-        },
-    });
-}
 export async function launchMSA({ algorithm, sequence, onProgress, }) {
     const config = algorithms[algorithm];
     onProgress(`Launching ${algorithm} MSA...`);
-    const jobId = await textfetch(`${base}/${algorithm}/run`, {
-        method: 'POST',
-        body: new URLSearchParams({ ...config.params, sequence }),
+    const jobId = await submitEbiJob({
+        tool: algorithm,
+        params: { ...config.params, sequence },
+    });
+    await waitForEbiJob({
+        tool: algorithm,
+        jobId,
+        onCountdown: s => {
+            onProgress(`Re-checking MSA status in... ${s}`);
+        },
     });
-    await wait({ jobId, algorithm, onProgress });
     return {
-        msa: await textfetch(`${base}/${algorithm}/result/${jobId}/${config.msaResult}`),
-        tree: await textfetch(`${base}/${algorithm}/result/${jobId}/${config.treeResult}`),
+        msa: await fetchEbiResult({
+            tool: algorithm,
+            jobId,
+            type: config.msaResult,
+        }),
+        tree: await fetchEbiResult({
+            tool: algorithm,
+            jobId,
+            type: config.treeResult,
+        }),
     };
 }

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.9.0";

package/dist/version.js

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.8.2",
+  "version": "2.9.0",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {

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>