jbrowse-plugin-msaview 2.8.2 → 2.10.0

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastRIDPanel.d.ts → BlastQuery/BlastAutomaticPanel.d.ts}

@@ -1,10 +1,9 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
-declare const NCBIBlastRIDPanel: ({ handleClose, feature, model, children, baseUrl, }: {
+declare const BlastAutomaticPanel: ({ handleClose, feature, model, children, }: {
     model: AbstractTrackModel;
     feature: Feature;
-    baseUrl: string;
     handleClose: () => void;
     children: React.ReactNode;
 }) => React.JSX.Element;
-export default NCBIBlastRIDPanel;
+export default BlastAutomaticPanel;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastAutomaticPanel.js → BlastQuery/BlastAutomaticPanel.js}

@@ -6,7 +6,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 { getBlastViewTitle, getGeneIdentifiers, getLinearGenomeView, } from '../../util';
@@ -18,13 +18,6 @@ const useStyles = makeStyles()({
     selectField: {
         width: 150,
     },
-    databaseFieldContainer: {
-        display: 'flex',
-    },
-    clusterSeqMessage: {
-        marginLeft: 4,
-        alignContent: 'center',
-    },
     cachedResultsAccordion: {
         marginTop: 20,
     },
@@ -32,13 +25,12 @@ const useStyles = makeStyles()({
         marginTop: 20,
     },
 });
-const NCBIBlastAutomaticPanel = observer(function ({ handleClose, feature, model, children, baseUrl, }) {
+const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, children, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
     const [launchViewError, setLaunchViewError] = useState();
-    const [selectedBlastDatabase, setSelectedBlastDatabase] = useState('nr');
+    const [selectedBlastDatabase, setSelectedBlastDatabase] = useState(defaultBlastDatabase);
     const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useState('clustalo');
-    const [selectedBlastProgram, setSelectedBlastProgram] = useState('quick-blastp');
     const geneIds = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const { results: cachedResults, error: cachedResultsError } = useCachedBlastResults(geneIds);
     const transcriptSelection = useTranscriptSelection({ feature, view });
@@ -48,20 +40,11 @@ const NCBIBlastAutomaticPanel = observer(function ({ handleClose, feature, model
         React.createElement(LaunchPanelContent, { error: e },
             children,
             React.createElement(TextField2, { variant: "outlined", label: "BLAST database", className: classes.selectField, select: true, value: selectedBlastDatabase, onChange: event => {
-                    const newDb = event.target.value;
-                    setSelectedBlastDatabase(newDb);
-                    if (newDb === 'nr_cluster_seq') {
-                        setSelectedBlastProgram('blastp');
-                    }
+                    setSelectedBlastDatabase(event.target.value);
                 } }, blastDatabaseOptions.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
             React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: selectedMsaAlgorithm, onChange: setSelectedMsaAlgorithm }),
-            React.createElement("div", { className: classes.databaseFieldContainer },
-                React.createElement(TextField2, { variant: "outlined", label: "BLAST program", disabled: selectedBlastDatabase === 'nr_cluster_seq', className: classes.selectField, select: true, value: selectedBlastProgram, onChange: event => {
-                        setSelectedBlastProgram(event.target.value);
-                    } }, blastPrograms.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
-                selectedBlastDatabase === 'nr_cluster_seq' ? (React.createElement(Typography, { variant: "subtitle2", className: classes.clusterSeqMessage }, "Can only use blastp on nr_cluster_seq")) : null),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
-            React.createElement(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"),
+            React.createElement(Typography, { className: classes.infoText }, "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."),
             cachedResults.length > 0 ? (React.createElement(Accordion, { className: classes.cachedResultsAccordion },
                 React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMoreIcon, null) },
                     React.createElement(Typography, null, "Previous BLAST Results")),
@@ -76,8 +59,6 @@ const NCBIBlastAutomaticPanel = observer(function ({ handleClose, feature, model
                             view,
                             newViewTitle: getBlastViewTitle(feature, selectedTranscript),
                             blastParams: {
-                                baseUrl,
-                                blastProgram: selectedBlastProgram,
                                 blastDatabase: selectedBlastDatabase,
                                 msaAlgorithm: selectedMsaAlgorithm,
                                 selectedTranscript,
@@ -93,4 +74,4 @@ const NCBIBlastAutomaticPanel = observer(function ({ handleClose, feature, model
                 }
             }, onCancel: handleClose })));
 });
-export default NCBIBlastAutomaticPanel;
+export default BlastAutomaticPanel;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastManualPanel.d.ts → BlastQuery/BlastManualPanel.d.ts}

@@ -1,10 +1,9 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
-declare const NCBIBlastManualPanel: ({ handleClose, feature, model, children, baseUrl, }: {
+declare const BlastManualPanel: ({ handleClose, feature, model, children, }: {
     children: React.ReactNode;
     model: AbstractTrackModel;
     feature: Feature;
-    baseUrl: string;
     handleClose: () => void;
 }) => React.JSX.Element;
-export default NCBIBlastManualPanel;
+export default BlastManualPanel;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastManualPanel.js → BlastQuery/BlastManualPanel.js}

@@ -3,6 +3,7 @@ import { shorten2 } from '@jbrowse/core/util';
 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';
@@ -18,14 +19,16 @@ const useStyles = makeStyles()({
         marginTop: 20,
     },
 });
-const NCBIBlastManualPanel = observer(function ({ handleClose, feature, model, children, baseUrl, }) {
+const BlastManualPanel = observer(function ({ handleClose, feature, model, children, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
     const transcriptSelection = useTranscriptSelection({ feature, view });
     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 (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: error },
             children,
@@ -39,4 +42,4 @@ const NCBIBlastManualPanel = observer(function ({ handleClose, feature, model, c
                     handleClose();
                 } }, "Close"))));
 });
-export default NCBIBlastManualPanel;
+export default BlastManualPanel;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastMethodSelector.d.ts → BlastQuery/BlastMethodSelector.d.ts}

@@ -1,6 +1,6 @@
 import React from 'react';
-import type { BlastLookupMethod } from './NCBIBlastPanel';
-export default function NCBIBlastMethodSelector({ lookupMethod, setLookupMethod, }: {
+import type { BlastLookupMethod } from './BlastPanel';
+export default function BlastMethodSelector({ lookupMethod, setLookupMethod, }: {
     lookupMethod: BlastLookupMethod;
     setLookupMethod: (method: BlastLookupMethod) => void;
 }): React.JSX.Element;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastMethodSelector.js → BlastQuery/BlastMethodSelector.js}

@@ -1,11 +1,10 @@
 import React from 'react';
 import { FormControl, FormControlLabel, Radio, RadioGroup } from '@mui/material';
-export default function NCBIBlastMethodSelector({ lookupMethod, setLookupMethod, }) {
+export default function BlastMethodSelector({ lookupMethod, setLookupMethod, }) {
     return (React.createElement(FormControl, { component: "fieldset" },
         React.createElement(RadioGroup, { row: true, value: lookupMethod, onChange: event => {
                 setLookupMethod(event.target.value);
             } },
             React.createElement(FormControlLabel, { value: "automatic", control: React.createElement(Radio, null), label: "Automatic" }),
-            React.createElement(FormControlLabel, { value: "rid", control: React.createElement(Radio, null), label: "Load from RID" }),
             React.createElement(FormControlLabel, { value: "manual", control: React.createElement(Radio, null), label: "Manual" }))));
 }

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastPanel.d.ts → BlastQuery/BlastPanel.d.ts}

@@ -1,30 +1,21 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
 declare const panelMap: {
-    readonly automatic: ({ handleClose, feature, model, children, baseUrl, }: {
+    readonly automatic: ({ handleClose, feature, model, children, }: {
         model: AbstractTrackModel;
         feature: Feature;
-        baseUrl: string;
         handleClose: () => void;
         children: React.ReactNode;
     }) => React.JSX.Element;
-    readonly rid: ({ handleClose, feature, model, children, baseUrl, }: {
-        model: AbstractTrackModel;
-        feature: Feature;
-        baseUrl: string;
-        handleClose: () => void;
-        children: React.ReactNode;
-    }) => React.JSX.Element;
-    readonly manual: ({ handleClose, feature, model, children, baseUrl, }: {
+    readonly manual: ({ handleClose, feature, model, children, }: {
         children: React.ReactNode;
         model: AbstractTrackModel;
         feature: Feature;
-        baseUrl: string;
         handleClose: () => void;
     }) => React.JSX.Element;
 };
 export type BlastLookupMethod = keyof typeof panelMap;
-export default function NCBIBlastPanel({ handleClose, model, feature, }: {
+export default function BlastPanel({ handleClose, model, feature, }: {
     handleClose: () => void;
     model: AbstractTrackModel;
     feature: Feature;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBIBlastPanel.js → BlastQuery/BlastPanel.js}

@@ -2,12 +2,11 @@ import React, { useState } from 'react';
 import SettingsIcon from '@mui/icons-material/Settings';
 import { IconButton } from '@mui/material';
 import { makeStyles } from 'tss-react/mui';
-import NCBIBlastAutomaticPanel from './NCBIBlastAutomaticPanel';
-import NCBIBlastManualPanel from './NCBIBlastManualPanel';
-import NCBIBlastMethodSelector from './NCBIBlastMethodSelector';
-import NCBIBlastRIDPanel from './NCBIBlastRIDPanel';
-import NCBISettingsDialog from './NCBISettingsDialog';
-import { BASE_BLAST_URL } from './consts';
+import BlastAutomaticPanel from './BlastAutomaticPanel';
+import BlastManualPanel from './BlastManualPanel';
+import BlastMethodSelector from './BlastMethodSelector';
+import BlastSettingsDialog from './BlastSettingsDialog';
+import { DEFAULT_EBI_EMAIL, EBI_EMAIL_STORAGE_KEY, } from '../../../utils/ebiJobDispatcher';
 import { useLocalStorage } from '../../../utils/useLocalStorage';
 const useStyles = makeStyles()({
     settingsButton: {
@@ -15,13 +14,12 @@ const useStyles = makeStyles()({
     },
 });
 const panelMap = {
-    automatic: NCBIBlastAutomaticPanel,
-    rid: NCBIBlastRIDPanel,
-    manual: NCBIBlastManualPanel,
+    automatic: BlastAutomaticPanel,
+    manual: BlastManualPanel,
 };
-export default function NCBIBlastPanel({ handleClose, model, feature, }) {
+export default function BlastPanel({ handleClose, model, feature, }) {
     const [lookupMethod, setLookupMethod] = useState('automatic');
-    const [baseUrl, setBaseUrl] = useLocalStorage('msa-blastRootUrl', BASE_BLAST_URL);
+    const [ebiEmail, setEbiEmail] = useLocalStorage(EBI_EMAIL_STORAGE_KEY, DEFAULT_EBI_EMAIL);
     const [settingsOpen, setSettingsOpen] = useState(false);
     const { classes } = useStyles();
     const Panel = panelMap[lookupMethod];
@@ -30,11 +28,11 @@ export default function NCBIBlastPanel({ handleClose, model, feature, }) {
                 setSettingsOpen(true);
             } },
             React.createElement(SettingsIcon, null)),
-        React.createElement(Panel, { model: model, feature: feature, handleClose: handleClose, baseUrl: baseUrl },
-            React.createElement(NCBIBlastMethodSelector, { lookupMethod: lookupMethod, setLookupMethod: setLookupMethod })),
-        settingsOpen ? (React.createElement(NCBISettingsDialog, { baseUrl: baseUrl, handleClose: newUrl => {
-                if (newUrl) {
-                    setBaseUrl(newUrl);
+        React.createElement(Panel, { model: model, feature: feature, handleClose: handleClose },
+            React.createElement(BlastMethodSelector, { lookupMethod: lookupMethod, setLookupMethod: setLookupMethod })),
+        settingsOpen ? (React.createElement(BlastSettingsDialog, { ebiEmail: ebiEmail, handleClose: settings => {
+                if (settings) {
+                    setEbiEmail(settings.ebiEmail);
                 }
                 setSettingsOpen(false);
             } })) : null));

package/dist/LaunchMsaView/components/BlastQuery/BlastSettingsDialog.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface BlastSettings {
+    ebiEmail: string;
+}
+export default function BlastSettingsDialog({ handleClose, ebiEmail, }: {
+    handleClose: (arg?: BlastSettings) => void;
+    ebiEmail: string;
+}): React.JSX.Element;

package/dist/LaunchMsaView/components/{NCBIBlastQuery/NCBISettingsDialog.js → BlastQuery/BlastSettingsDialog.js}

@@ -1,32 +1,36 @@
 import React, { useState } from 'react';
-import { Button, Dialog, DialogActions, DialogContent, DialogTitle, } from '@mui/material';
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, Typography, } from '@mui/material';
 import { makeStyles } from 'tss-react/mui';
-import { BASE_BLAST_URL } from './consts';
 import TextField2 from '../../../components/TextField2';
+import { DEFAULT_EBI_EMAIL } from '../../../utils/ebiJobDispatcher';
 const useStyles = makeStyles()({
-    urlField: {
+    field: {
         minWidth: 300,
     },
+    help: {
+        marginBottom: 8,
+    },
 });
-export default function NCBISettingsDialog({ handleClose, baseUrl, }) {
+export default function BlastSettingsDialog({ handleClose, ebiEmail, }) {
     const { classes } = useStyles();
-    const [tempBaseUrl, setTempBaseUrl] = useState(baseUrl);
+    const [tempEbiEmail, setTempEbiEmail] = useState(ebiEmail);
     return (React.createElement(Dialog, { open: true, maxWidth: "lg", onClose: () => {
             handleClose();
         } },
         React.createElement(DialogTitle, null, "BLAST Settings"),
         React.createElement(DialogContent, null,
-            React.createElement(TextField2, { autoFocus: true, margin: "dense", label: "BLAST Base URL", fullWidth: true, variant: "outlined", value: tempBaseUrl, className: classes.urlField, onChange: e => {
-                    setTempBaseUrl(e.target.value);
+            React.createElement(Typography, { variant: "subtitle2", className: classes.help }, "Searches run at EBI, which asks for a contact address on every job so they can reach whoever is generating the load. If your site sends real volume, use your own."),
+            React.createElement(TextField2, { autoFocus: true, margin: "dense", label: "EBI contact email", fullWidth: true, variant: "outlined", value: tempEbiEmail, className: classes.field, onChange: e => {
+                    setTempEbiEmail(e.target.value);
                 } }),
             React.createElement(Button, { variant: "contained", onClick: () => {
-                    setTempBaseUrl(BASE_BLAST_URL);
+                    setTempEbiEmail(DEFAULT_EBI_EMAIL);
                 } }, "Reset")),
         React.createElement(DialogActions, null,
             React.createElement(Button, { variant: "contained", color: "secondary", onClick: () => {
                     handleClose();
                 } }, "Cancel"),
             React.createElement(Button, { color: "primary", variant: "contained", onClick: () => {
-                    handleClose(tempBaseUrl);
+                    handleClose({ ebiEmail: tempEbiEmail });
                 } }, "Save"))));
 }

package/dist/LaunchMsaView/components/{NCBIBlastQuery → BlastQuery}/CachedBlastResults.js

@@ -83,6 +83,6 @@ const CachedBlastResults = observer(function ({ model, handleClose, feature, })
             React.createElement(ListItemButton, { onClick: () => {
                     handleUseCached(result);
                 } },
-                React.createElement(ListItemText, { primary: `${getResultDisplayName(result)} - ${result.blastDatabase}/${result.blastProgram} (${result.msaAlgorithm})`, secondary: `${new Date(result.timestamp).toLocaleString()} - Seq: ${result.proteinSequence.slice(0, 30)}...` }))))))));
+                React.createElement(ListItemText, { primary: `${getResultDisplayName(result)} - ${result.blastDatabase}${result.blastProgram ? `/${result.blastProgram}` : ''} (${result.msaAlgorithm})`, secondary: `${new Date(result.timestamp).toLocaleString()} - Seq: ${result.proteinSequence.slice(0, 30)}...` }))))))));
 });
 export default CachedBlastResults;

package/dist/LaunchMsaView/components/BlastQuery/consts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Only used to build the link-out on the manual panel, which sends the user to
+ * NCBI's own site to run BLAST there. Nothing fetches this url: NCBI stopped
+ * sending Access-Control-Allow-Origin to third-party origins, so a browser
+ * cannot read a response from it at all. See docs/blast.md.
+ */
+export declare const BASE_BLAST_URL = "https://blast.ncbi.nlm.nih.gov/Blast.cgi";
+export declare const msaAlgorithms: readonly ["clustalo", "muscle", "kalign", "mafft"];
+export type MsaAlgorithm = (typeof msaAlgorithms)[number];
+export declare const blastDatabaseOptions: readonly ["uniprotkb_swissprot", "uniprotkb", "uniprotkb_reference_proteomes", "uniprotkb_trembl"];
+export type BlastDatabase = (typeof blastDatabaseOptions)[number];
+export declare const defaultBlastDatabase: BlastDatabase;

package/dist/LaunchMsaView/components/BlastQuery/consts.js

@@ -0,0 +1,17 @@
+/**
+ * Only used to build the link-out on the manual panel, which sends the user to
+ * NCBI's own site to run BLAST there. Nothing fetches this url: NCBI stopped
+ * sending Access-Control-Allow-Origin to third-party origins, so a browser
+ * cannot read a response from it at all. See docs/blast.md.
+ */
+export const BASE_BLAST_URL = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi';
+export const msaAlgorithms = ['clustalo', 'muscle', 'kalign', 'mafft'];
+export const blastDatabaseOptions = [
+    'uniprotkb_swissprot',
+    'uniprotkb',
+    'uniprotkb_reference_proteomes',
+    'uniprotkb_trembl',
+];
+// curated, so it returns roughly one good sequence per species rather than the
+// many near-identical TrEMBL entries an alignment reads poorly
+export const defaultBlastDatabase = 'uniprotkb_swissprot';

package/dist/LaunchMsaView/components/LaunchMsaViewDialog.js

@@ -2,8 +2,8 @@ import React, { useState } from 'react';
 import { Dialog } from '@jbrowse/core/ui';
 import { getSession } from '@jbrowse/core/util';
 import { Tab, Tabs } from '@mui/material';
+import BlastPanel from './BlastQuery/BlastPanel';
 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';
@@ -20,13 +20,13 @@ export default function LaunchMsaViewDialog({ handleClose, feature, model, }) {
                 setValue(newValue);
             } },
             React.createElement(Tab, { label: "Orthologs (fast)", value: "orthologs" }),
-            React.createElement(Tab, { label: "NCBI BLAST query", value: "ncbi_blast" }),
+            React.createElement(Tab, { label: "BLAST query", value: "ncbi_blast" }),
             hasPreloadedDatasets ? (React.createElement(Tab, { label: "Pre-loaded MSA datasets", value: "preloaded_msa" })) : null,
             React.createElement(Tab, { label: "Manual upload", value: "manual_msa" })),
         React.createElement(TabPanel, { value: value, index: "orthologs" },
             React.createElement(OrthologPanel, { handleClose: handleClose, feature: feature, model: model })),
         React.createElement(TabPanel, { value: value, index: "ncbi_blast" },
-            React.createElement(NCBIBlastPanel, { handleClose: handleClose, feature: feature, model: model })),
+            React.createElement(BlastPanel, { handleClose: handleClose, feature: feature, model: model })),
         hasPreloadedDatasets ? (React.createElement(TabPanel, { value: value, index: "preloaded_msa" },
             React.createElement(PreLoadedMSA, { model: model, feature: feature, handleClose: handleClose }))) : null,
         React.createElement(TabPanel, { value: value, index: "manual_msa" },

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -1,13 +1,14 @@
 import React, { useMemo, useState } from 'react';
-import { Checkbox, FormControlLabel, MenuItem, Typography } from '@mui/material';
+import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
+import QuerySpeciesSelect from './QuerySpeciesSelect';
 import { orthologLaunchView } from './orthologLaunchView';
 import TextField2 from '../../../components/TextField2';
-import { COMMON_SPECIES } from '../../../utils/ncbiOrthologs';
+import { defaultMaxSpecies } from '../../../utils/ncbiOrthologs';
 import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
+import MsaAlgorithmSelect from '../BlastQuery/MsaAlgorithmSelect';
 import LaunchPanelContent from '../LaunchPanelContent';
-import MsaAlgorithmSelect from '../NCBIBlastQuery/MsaAlgorithmSelect';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
@@ -15,23 +16,6 @@ const useStyles = makeStyles()({
     selectField: {
         width: 180,
     },
-    // A GRID, not a wrapping flex row of fixed-width items. The old form was three
-    // 160px columns inside a 560px box, which is five rows for thirteen species and
-    // eight for twenty-three -- and the checkbox list is the tallest thing in the
-    // dialog, so those rows are the dialog's height. Five auto-fitted columns is
-    // five rows for twenty-three, i.e. more species in less space, and it reflows
-    // rather than being pinned to a width the dialog may not have.
-    speciesBox: {
-        display: 'grid',
-        gridTemplateColumns: 'repeat(auto-fit, minmax(130px, 1fr))',
-        maxWidth: 700,
-        marginTop: 4,
-    },
-    // The label carries the row height; the default control padding is what makes
-    // 23 rows of it tall.
-    species: {
-        marginRight: 0,
-    },
 });
 const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const { classes } = useStyles();
@@ -39,28 +23,24 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const [launchViewError, setLaunchViewError] = useState();
     const [taxId, setTaxId] = useState(9606);
     const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
-    const [excluded, setExcluded] = useState([]);
+    const [maxSpecies, setMaxSpecies] = useState(String(defaultMaxSpecies));
     const geneCandidates = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const transcriptSelection = useTranscriptSelection({ feature, view });
     const { selectedTranscript, proteinSequence } = transcriptSelection;
     const e = transcriptSelection.error ?? launchViewError;
-    const taxa = COMMON_SPECIES.map(s => s.taxId).filter(t => !excluded.includes(t));
+    const rowCount = Number(maxSpecies);
+    const rowCountValid = Number.isInteger(rowCount) && rowCount >= 2;
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
-            React.createElement(Typography, { variant: "body2" }, "NCBI's precomputed orthologs, one gene per species, aligned at EBI in seconds rather than the 10+ minutes BLAST takes."),
+            React.createElement(Typography, { variant: "body2" }, "NCBI's precomputed orthologs, one gene per species, looked up rather than searched for. No BLAST job to queue."),
             React.createElement("div", null,
-                React.createElement(TextField2, { variant: "outlined", label: "Query species", className: classes.selectField, select: true, value: taxId, onChange: event => {
-                        setTaxId(Number(event.target.value));
-                    }, helperText: "the species this gene is from" }, COMMON_SPECIES.map(s => (React.createElement(MenuItem, { value: s.taxId, key: s.taxId }, s.label)))),
-                React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: msaAlgorithm, onChange: setMsaAlgorithm })),
-            React.createElement(Typography, { variant: "subtitle2", style: { marginTop: 8 } }, "Species to include (those without an ortholog are skipped)"),
-            React.createElement("div", { className: classes.speciesBox }, COMMON_SPECIES.map(s => (React.createElement(FormControlLabel, { className: classes.species, key: s.taxId, control: React.createElement(Checkbox, { checked: !excluded.includes(s.taxId), onChange: event => {
-                        setExcluded(event.target.checked
-                            ? excluded.filter(t => t !== s.taxId)
-                            : [...excluded, s.taxId]);
-                    } }), label: s.label })))),
+                React.createElement(QuerySpeciesSelect, { className: classes.selectField, value: taxId, onChange: setTaxId }),
+                React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: msaAlgorithm, onChange: setMsaAlgorithm }),
+                React.createElement(TextField2, { variant: "outlined", label: "Rows to align", className: classes.selectField, type: "number", value: maxSpecies, onChange: event => {
+                        setMaxSpecies(event.target.value);
+                    }, error: !rowCountValid, helperText: "the closest N species NCBI has" })),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection })),
-        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || taxa.length < 2, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || !rowCountValid, onSubmit: () => {
                 try {
                     if (selectedTranscript) {
                         setLaunchViewError(undefined);
@@ -70,7 +50,7 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
                             newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
                             orthologParams: {
                                 taxId,
-                                taxa,
+                                maxSpecies: rowCount,
                                 geneCandidates,
                                 msaAlgorithm,
                                 selectedTranscript,

package/dist/LaunchMsaView/components/OrthologQuery/QuerySpeciesSelect.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+/**
+ * The species the query gene came from, as free text resolved against NCBI's
+ * taxonomy rather than picked from a fixed list.
+ *
+ * The resolved taxon is shown back as helper text, which is the whole point of
+ * resolving on a debounce instead of on submit: a typo resolves to some other
+ * organism rather than to nothing, and the only place that surfaces is the gene
+ * lookup, as "could not resolve NLRP1 in taxon 9986".
+ */
+export default function QuerySpeciesSelect({ value, onChange, className, }: {
+    value: number;
+    onChange: (taxId: number) => void;
+    className?: string;
+}): React.JSX.Element;

package/dist/LaunchMsaView/components/OrthologQuery/QuerySpeciesSelect.js

@@ -0,0 +1,67 @@
+import React, { useEffect, useState } from 'react';
+import TextField2 from '../../../components/TextField2';
+import { resolveTaxId } from '../../../utils/ncbiTaxonomy';
+import { fetchTaxonomyInfo } from '../../../utils/taxonomyNames';
+/**
+ * The species the query gene came from, as free text resolved against NCBI's
+ * taxonomy rather than picked from a fixed list.
+ *
+ * The resolved taxon is shown back as helper text, which is the whole point of
+ * resolving on a debounce instead of on submit: a typo resolves to some other
+ * organism rather than to nothing, and the only place that surfaces is the gene
+ * lookup, as "could not resolve NLRP1 in taxon 9986".
+ */
+export default function QuerySpeciesSelect({ value, onChange, className, }) {
+    const [text, setText] = useState('human');
+    const [resolved, setResolved] = useState();
+    const [error, setError] = useState();
+    useEffect(() => {
+        // read through a call rather than as a property: the cleanup writes it from
+        // another turn of the loop, and a bare `run.live` narrows to true after the
+        // first check, which reads to the compiler as a redundant second one
+        const run = { live: true };
+        const cancelled = () => !run.live;
+        async function lookup() {
+            try {
+                setError(undefined);
+                const taxId = await resolveTaxId(text);
+                if (cancelled()) {
+                    return;
+                }
+                if (!taxId) {
+                    setResolved(undefined);
+                    setError(new Error(`No NCBI taxon matches "${text}"`));
+                    return;
+                }
+                const info = (await fetchTaxonomyInfo([taxId])).get(taxId);
+                if (cancelled()) {
+                    return;
+                }
+                setResolved([info?.sciname, info?.commonName && `(${info.commonName})`]
+                    .filter(Boolean)
+                    .join(' ') || `taxon ${taxId}`);
+                onChange(taxId);
+            }
+            catch (e) {
+                if (!cancelled()) {
+                    setError(e);
+                }
+            }
+        }
+        const timer = setTimeout(() => {
+            void lookup();
+        }, 400);
+        return () => {
+            run.live = false;
+            clearTimeout(timer);
+        };
+        // onChange is a setState updater from the parent and stable in practice;
+        // including it would re-run the lookup on every parent render
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [text]);
+    return (React.createElement(TextField2, { variant: "outlined", label: "Query species", className: className, value: text, onChange: event => {
+            setText(event.target.value);
+        }, error: !!error, helperText: error
+            ? `${error}`
+            : (resolved ?? `the species this gene is from (taxon ${value})`) }));
+}

package/dist/LaunchMsaView/index.js

@@ -4,6 +4,24 @@ import LaunchMsaViewDialog from './components/LaunchMsaViewDialog';
 function isDisplay(elt) {
     return elt.name === 'LinearBasicDisplay';
 }
+// Read off the clicked item rather than off the display.
+//
+// LinearBasicDisplay used to publish an `isGeneLike` getter and this gated on
+// it. jbrowse-components 684142b3 (2026-08-16) inlined that getter into its own
+// `contextMenuItems`, and every host built after it returns `undefined` here --
+// so the gate was never satisfied, `onClick` stayed undefined, and the item
+// silently left the right-click menu on every gene track. Nothing failed loudly:
+// the display still had contextMenuInfo and fetchFullFeature, and the menu still
+// opened with its own items in it.
+//
+// A predicate over the type we were already given cannot go the same way, and it
+// costs one comparison. Deliberately the same loose case-insensitive test the
+// host applies (`isGeneLikeType` in collapseIntronsMenu.ts): real GFFs carry
+// 'mRNA', 'lnc_RNA', 'protein_coding_gene', 'transcript'.
+function isGeneLikeType(type) {
+    const t = (type ?? '').toLowerCase();
+    return t.includes('gene') || t.includes('rna') || t.includes('transcript');
+}
 const GENE_LIKE_TYPES = new Set(['gene', 'mRNA', 'transcript']);
 function extendStateModel(stateModel) {
     return stateModel.views((self) => {
@@ -21,7 +39,7 @@ function extendStateModel(stateModel) {
                 const info = self.contextMenuInfo;
                 const fetchFullFeature = self.fetchFullFeature;
                 const legacyFeature = self.contextMenuFeature;
-                const onClick = info && fetchFullFeature && self.isGeneLike
+                const onClick = info && fetchFullFeature && isGeneLikeType(info.item.type)
                     ? () => {
                         fetchFullFeature(info.item.featureId, info.displayedRegionIndex)
                             .then(feature => {

package/dist/MsaViewPanel/components/JobLink.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+declare function JobLink({ jobId }: {
+    jobId: string;
+}): React.JSX.Element;
+export default JobLink;

package/dist/MsaViewPanel/components/JobLink.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { Typography } from '@mui/material';
+import ExternalLink from '../../components/ExternalLink';
+import { ebiBlastResultUrl } from '../../utils/ebiBlast';
+function JobLink({ jobId }) {
+    return (React.createElement(Typography, null,
+        "Job ",
+        jobId,
+        " (",
+        React.createElement(ExternalLink, { href: ebiBlastResultUrl(jobId) }, "see status"),
+        ")"));
+}
+export default JobLink;

package/dist/MsaViewPanel/components/LoadingBLAST.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
 import type { JBrowsePluginMsaViewModel } from '../model';
-declare const LoadingBLAST: ({ model, baseUrl, }: {
+declare const LoadingBLAST: ({ model, }: {
     model: JBrowsePluginMsaViewModel;
-    baseUrl: string;
 }) => React.JSX.Element;
 export default LoadingBLAST;