jbrowse-plugin-msaview 3.4.1 → 3.6.0

package/README.md

@@ -29,6 +29,13 @@ https://jbrowse.org/code/jb2/main/index.html?config=https://unpkg.com/jbrowse-pl
 - Can share sessions with other users which will send relevant settings and
   links to files to automatically open your results
 - The tree or the MSA panel can be loaded separately from each other
+- Builds a cross-species alignment for any gene from the genome view's
+  right-click menu: precomputed orthologs (NCBI, PANTHER), the gene's UniRef
+  cluster across all of UniProtKB, or a phmmer/blastp search at EBI
+- Aligns and builds trees in the browser, so a UniRef launch needs no job at any
+  external service; EBI's aligners remain an option
+- Every launch is also a session-spec URL (`orthologParams`, `searchParams`,
+  `connectedTranscript`), see [DEVELOPERS.md](DEVELOPERS.md)
 
 ## File format supports
 

package/dist/AddHighlightModel/index.js

@@ -3,9 +3,9 @@ import { getSession } from '@jbrowse/core/util';
 import { isMsaView } from '../MsaViewPanel/model';
 import HighlightComponents from './HighlightComponents';
 export default function AddHighlightComponentsModelF(pluginManager) {
-    pluginManager.addToExtensionPoint('LinearGenomeView-TracksContainerComponent', 
-    // @ts-expect-error
-    (rest, { model }) => {
+    pluginManager.addToExtensionPoint(
+    // @ts-expect-error v4 hosts have no contributeToExtensionPoint
+    'LinearGenomeView-TracksContainerComponent', (rest, { model }) => {
         // Quick check: don't add any components if no MSA view exists
         const { views } = getSession(model);
         const hasMsaView = views.some(v => isMsaView(v) && v.connectedViewId === model.id);

package/dist/BgzipFastaMsaAdapter/BgzipFastaMsaAdapter.d.ts

@@ -3,8 +3,14 @@ import type { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAda
 export default class BgzipFastaMsaAdapter extends BaseAdapter {
     configureP: Promise<BaseFeatureDataAdapter> | undefined;
     refNamesP: Promise<string[]> | undefined;
-    configurePre(): Promise<BaseFeatureDataAdapter>;
-    configure(): Promise<BaseFeatureDataAdapter>;
+    configurePre(): Promise<BaseFeatureDataAdapter<import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+        setSubschema(slotName: string, data: Record<string, unknown>): any;
+        setSlot(slotName: string, value: unknown): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>>>;
+    configure(): Promise<BaseFeatureDataAdapter<import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+        setSubschema(slotName: string, data: Record<string, unknown>): any;
+        setSlot(slotName: string, value: unknown): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>>>;
     getMSARefs(): Promise<string[]>;
     getMsaRegex(): RegExp;
     refNameToMsaId(refName: string): string;

package/dist/BgzipFastaMsaAdapter/configSchema.d.ts

@@ -1,7 +1,7 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 export default function configSchemaF(pluginManager: PluginManager): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    msaRegex: {
-        type: string;
-        defaultValue: string;
+    readonly msaRegex: {
+        readonly type: "string";
+        readonly defaultValue: "_";
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration").AnyConfigurationSchemaType, undefined>>;

package/dist/BgzipFastaMsaAdapter/configSchema.js

@@ -7,6 +7,6 @@ export default function configSchemaF(pluginManager) {
             defaultValue: '_',
         },
     }, {
-        baseConfiguration: base?.configSchema,
+        baseConfiguration: base.configSchema,
     });
 }

package/dist/LaunchMsaView/codingFeature.d.ts

@@ -0,0 +1,14 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function isGeneLikeType(type: unknown): boolean;
+export declare function isCodingFeature(feature: Feature): boolean;
+/**
+ * Whether the feature is known not to code for anything.
+ *
+ * Not simply `!isCodingFeature`: a feature that arrived with no subfeatures at
+ * all says nothing either way, and a host is free to hand one over that way.
+ * Reading that as "no protein here" takes the menu item off a perfectly
+ * ordinary gene, silently, which is worse than opening a dialog that then has
+ * nothing to translate.
+ */
+export declare function isKnownNonCoding(feature: Feature): boolean;
+export declare function geneLikeRoot(feature: Feature): Feature;

package/dist/LaunchMsaView/codingFeature.js

@@ -0,0 +1,38 @@
+// Copied from @jbrowse/core's featureTypes rather than imported: the barrel
+// only exports it from v5, and a bundle resolving it on a v4 host reads
+// undefined.
+const GENE_LIKE_TYPE = /gene(_segment)?$|rna$|transcript/;
+// `unknown` rather than `string | undefined`, because the type comes off a
+// host's hit-test item and nothing here built it.
+export function isGeneLikeType(type) {
+    return typeof type === 'string' && GENE_LIKE_TYPE.test(type.toLowerCase());
+}
+function isCDS(feature) {
+    return feature.get('type')?.toLowerCase() === 'cds';
+}
+// The feature itself counts: a viral polyprotein hangs its cleavage products
+// off its CDS rather than off further CDSs.
+export function isCodingFeature(feature) {
+    return isCDS(feature) || !!feature.get('subfeatures')?.some(isCodingFeature);
+}
+/**
+ * Whether the feature is known not to code for anything.
+ *
+ * Not simply `!isCodingFeature`: a feature that arrived with no subfeatures at
+ * all says nothing either way, and a host is free to hand one over that way.
+ * Reading that as "no protein here" takes the menu item off a perfectly
+ * ordinary gene, silently, which is worse than opening a dialog that then has
+ * nothing to translate.
+ */
+export function isKnownNonCoding(feature) {
+    return !!feature.get('subfeatures')?.length && !isCodingFeature(feature);
+}
+// The outermost gene-like ancestor, so a click on an isoform opens the dialog
+// on the gene with every transcript to choose from, as the canvas host does.
+export function geneLikeRoot(feature) {
+    let root = feature;
+    for (let parent = root.parent?.(); parent && isGeneLikeType(parent.get('type')); parent = parent.parent?.()) {
+        root = parent;
+    }
+    return root;
+}

package/dist/LaunchMsaView/codingFeature.test.js

@@ -0,0 +1,75 @@
+import { SimpleFeature } from '@jbrowse/core/util';
+import { describe, expect, it } from 'vitest';
+import { geneLikeRoot, isCodingFeature, isGeneLikeType, isKnownNonCoding, } from './codingFeature';
+function feature(type, subfeatures = []) {
+    return new SimpleFeature({
+        uniqueId: `${type}-${Math.random()}`,
+        refName: 'chr1',
+        start: 0,
+        end: 100,
+        type,
+        subfeatures: subfeatures.map(s => s.toJSON()),
+    });
+}
+describe('isGeneLikeType', () => {
+    it('accepts the SO spellings of gene, transcript and RNA', () => {
+        for (const t of [
+            'gene',
+            'mRNA',
+            'transcript',
+            'ncRNA_gene',
+            'protein_coding_gene',
+            'V_gene_segment',
+            'primary_transcript',
+            'pseudogenic_transcript',
+            'lnc_RNA',
+        ]) {
+            expect(isGeneLikeType(t)).toBe(true);
+        }
+    });
+    it('rejects regions, matches and CDS', () => {
+        for (const t of ['intergenic_region', 'cDNA_match', 'CDS', 'exon']) {
+            expect(isGeneLikeType(t)).toBe(false);
+        }
+        expect(isGeneLikeType(undefined)).toBe(false);
+    });
+});
+describe('isCodingFeature', () => {
+    it('finds a CDS anywhere below the feature', () => {
+        const gene = feature('gene', [
+            feature('mRNA', [feature('exon'), feature('CDS')]),
+        ]);
+        expect(isCodingFeature(gene)).toBe(true);
+    });
+    it('is false for a transcript with exons only', () => {
+        const lnc = feature('lnc_RNA', [feature('exon'), feature('exon')]);
+        expect(isCodingFeature(lnc)).toBe(false);
+    });
+    it('counts the feature itself', () => {
+        expect(isCodingFeature(feature('CDS'))).toBe(true);
+    });
+});
+describe('isKnownNonCoding', () => {
+    it('is true for a transcript whose subfeatures are all exons', () => {
+        expect(isKnownNonCoding(feature('lnc_RNA', [feature('exon'), feature('exon')]))).toBe(true);
+    });
+    // a host is free to hand over a bare record, and reading that as "no protein
+    // here" takes the menu item off an ordinary gene without a word
+    it('is false for a feature that arrived with no subfeatures at all', () => {
+        expect(isKnownNonCoding(feature('gene'))).toBe(false);
+    });
+    it('is false when a CDS is somewhere below', () => {
+        expect(isKnownNonCoding(feature('gene', [feature('mRNA', [feature('CDS')])]))).toBe(false);
+    });
+});
+describe('geneLikeRoot', () => {
+    it('climbs from an isoform to its gene', () => {
+        const gene = feature('gene', [feature('mRNA', [feature('CDS')])]);
+        const mrna = gene.get('subfeatures')[0];
+        expect(geneLikeRoot(mrna)).toBe(gene);
+    });
+    it('stays put with no gene-like parent', () => {
+        const mrna = feature('mRNA', [feature('CDS')]);
+        expect(geneLikeRoot(mrna)).toBe(mrna);
+    });
+});

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

@@ -1,9 +1,11 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
-declare const BlastAutomaticPanel: ({ handleClose, feature, model, children, }: {
+declare const BlastAutomaticPanel: ({ handleClose, feature, model, children, preferredTranscriptId, }: {
     model: AbstractTrackModel;
     feature: Feature;
     handleClose: () => void;
     children: React.ReactNode;
+    /** the isoform the user right-clicked, preselected in the picker */
+    preferredTranscriptId?: string;
 }) => React.JSX.Element;
 export default BlastAutomaticPanel;

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

@@ -6,24 +6,24 @@ import { makeStyles } from 'tss-react/mui';
 import TextField2 from '../../../components/TextField2';
 import { getBlastViewTitle, getGeneIdentifiers, getLinearGenomeView, } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
+import SequenceStatusMessage from '../SequenceStatus';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
 import CachedBlastResults from './CachedBlastResults';
 import MsaAlgorithmSelect from './MsaAlgorithmSelect';
 import { blastLaunchView } from './blastLaunchView';
-import { databaseOptionsFor, defaultSearchFor, searchPrograms } from './consts';
+import { databaseLabel, databaseOptionsFor, defaultMaxHits, defaultSearchFor, searchProgramLabels, searchPrograms, } from './consts';
 import { useStoredMsaAlgorithm, useStoredSearchChoice, } from './searchChoiceStorage';
 import { useCachedBlastResults } from './useCachedBlastResults';
 const useStyles = makeStyles()({
     selectField: {
         width: 150,
     },
-    // wider than the rest because the values are what the user came to read, and
-    // `uniprotkb_swissprot` is 19 characters — at 150 the field showed
-    // `uniprotkb_swis…`, which does not distinguish it from `uniprotkb_trembl`
+    // wider than the rest because the collection names are what the user came to
+    // read, and truncating them does not distinguish Swiss-Prot from TrEMBL
     databaseField: {
-        width: 230,
+        width: 260,
     },
     cachedResultsAccordion: {
         marginTop: 20,
@@ -32,7 +32,7 @@ const useStyles = makeStyles()({
         marginTop: 20,
     },
 });
-const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, children, }) {
+const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, children, preferredTranscriptId, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
     const [launchViewError, setLaunchViewError] = useState();
@@ -41,11 +41,18 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
     // would let them drift into that
     const [search, setSearch] = useStoredSearchChoice();
     const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useStoredMsaAlgorithm();
+    const [maxHits, setMaxHits] = useState(String(defaultMaxHits));
+    const hitCount = Number(maxHits);
+    const hitCountValid = Number.isInteger(hitCount) && hitCount >= 1;
     const isPhmmer = search.program === 'phmmer';
     const geneIds = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const { results: cachedResults, error: cachedResultsError } = useCachedBlastResults(geneIds);
-    const transcriptSelection = useTranscriptSelection({ feature, view });
-    const { selectedTranscript, proteinSequence } = transcriptSelection;
+    const transcriptSelection = useTranscriptSelection({
+        feature,
+        view,
+        preferredTranscriptId,
+    });
+    const { selectedTranscript, proteinSequence, sequenceStatus } = transcriptSelection;
     const e = transcriptSelection.error ?? launchViewError ?? cachedResultsError;
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
@@ -55,36 +62,30 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
                     // program replaces the database rather than keeping a name the new
                     // one has never heard of
                     setSearch(defaultSearchFor(event.target.value));
-                } }, searchPrograms.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
+                } }, searchPrograms.map(val => (React.createElement(MenuItem, { value: val, key: val }, searchProgramLabels[val])))),
             React.createElement(TextField2, { variant: "outlined", label: "Database", className: classes.databaseField, select: true, value: search.database, onChange: event => {
                     setSearch({
                         program: search.program,
                         database: event.target.value,
                     });
-                } }, databaseOptionsFor(search.program).map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))),
+                } }, databaseOptionsFor(search.program).map(val => (React.createElement(MenuItem, { value: val, key: val }, databaseLabel(val))))),
             isPhmmer ? null : (React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: selectedMsaAlgorithm, onChange: setSelectedMsaAlgorithm })),
+            React.createElement(TextField2, { variant: "outlined", label: "Hits", className: classes.selectField, type: "number", value: maxHits, onChange: event => {
+                    setMaxHits(event.target.value);
+                }, error: !hitCountValid, helperText: "best-scoring sequences to keep" }),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
-            React.createElement(Typography, { className: classes.infoText },
+            React.createElement(Typography, { variant: "body2", className: classes.infoText },
                 isPhmmer
-                    ? `phmmer searches UniProtKB with a profile HMM built from the query,
-               so it aligns the hits as it finds them and that alignment is used
-               directly — nothing is realigned afterwards. The tree is then built
-               from it by neighbour-joining. A hit matching the query in more
-               than one place appears once per matched region.`
-                    : `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.`,
+                    ? 'phmmer aligns the hits as it finds them, so nothing is realigned afterwards.'
+                    : 'The hits come back from EBI and are then run through the chosen aligner.',
                 ' ',
-                "Searching NCBI's nr needs the manual approach: NCBI no longer lets a browser read responses from Blast.cgi."),
+                "The EBI queue is the wait, and it runs from seconds to many minutes."),
             cachedResults.length > 0 ? (React.createElement(Accordion, { className: classes.cachedResultsAccordion },
                 React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMoreIcon, null) },
                     React.createElement(Typography, null, "Previous BLAST Results")),
                 React.createElement(AccordionDetails, null,
                     React.createElement(CachedBlastResults, { model: model, handleClose: handleClose, feature: feature })))) : null),
-        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !proteinSequence, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { model: model, hint: React.createElement(SequenceStatusMessage, { status: sequenceStatus }), submitDisabled: !proteinSequence || !hitCountValid, onSubmit: () => {
                 try {
                     if (selectedTranscript) {
                         setLaunchViewError(undefined);
@@ -96,14 +97,16 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
                                 ? {
                                     searchProgram: 'phmmer',
                                     blastDatabase: search.database,
-                                    selectedTranscript,
+                                    maxHits: hitCount,
+                                    selectedTranscript: selectedTranscript.toJSON(),
                                     proteinSequence,
                                 }
                                 : {
                                     searchProgram: 'blastp',
                                     blastDatabase: search.database,
                                     msaAlgorithm: selectedMsaAlgorithm,
-                                    selectedTranscript,
+                                    maxHits: hitCount,
+                                    selectedTranscript: selectedTranscript.toJSON(),
                                     proteinSequence,
                                 },
                         });

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

@@ -11,10 +11,12 @@ import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
  * button -- leaving them to find the Manual upload tab, re-pick the transcript
  * they had already chosen here, and hand-type the row name.
  */
-declare const BlastManualPanel: ({ handleClose, feature, model, children, }: {
+declare const BlastManualPanel: ({ handleClose, feature, model, children, preferredTranscriptId, }: {
     children: React.ReactNode;
     model: AbstractTrackModel;
     feature: Feature;
     handleClose: () => void;
+    /** the isoform the user right-clicked, preselected in the picker */
+    preferredTranscriptId?: string;
 }) => React.JSX.Element;
 export default BlastManualPanel;

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

@@ -43,13 +43,17 @@ const useStyles = makeStyles()({
  * button -- leaving them to find the Manual upload tab, re-pick the transcript
  * they had already chosen here, and hand-type the row name.
  */
-const BlastManualPanel = observer(function ({ handleClose, feature, model, children, }) {
+const BlastManualPanel = observer(function ({ handleClose, feature, model, children, preferredTranscriptId, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
     const [launchViewError, setLaunchViewError] = useState();
     const [msaText, setMsaText] = useState('');
     const [treeText, setTreeText] = useState('');
-    const transcriptSelection = useTranscriptSelection({ feature, view });
+    const transcriptSelection = useTranscriptSelection({
+        feature,
+        view,
+        preferredTranscriptId,
+    });
     const { proteinSequence, selectedTranscript, error } = transcriptSelection;
     const queryRow = useQueryRowName(msaText, proteinSequence);
     const s2 = cleanProteinSequence(proteinSequence);
@@ -88,6 +92,7 @@ const BlastManualPanel = observer(function ({ handleClose, feature, model, child
                             view,
                             feature: selectedTranscript,
                             querySeqName: queryRow.querySeqName,
+                            querySeqOffset: queryRow.querySeqOffset,
                             data: { msa: msaText, tree: treeText },
                         });
                         handleClose();

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

@@ -1,23 +1,27 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
 declare const panelMap: {
-    readonly automatic: ({ handleClose, feature, model, children, }: {
+    readonly automatic: ({ handleClose, feature, model, children, preferredTranscriptId, }: {
         model: AbstractTrackModel;
         feature: Feature;
         handleClose: () => void;
         children: React.ReactNode;
+        preferredTranscriptId?: string;
     }) => React.JSX.Element;
-    readonly manual: ({ handleClose, feature, model, children, }: {
+    readonly manual: ({ handleClose, feature, model, children, preferredTranscriptId, }: {
         children: React.ReactNode;
         model: AbstractTrackModel;
         feature: Feature;
         handleClose: () => void;
+        preferredTranscriptId?: string;
     }) => React.JSX.Element;
 };
 export type BlastLookupMethod = keyof typeof panelMap;
-export default function BlastPanel({ handleClose, model, feature, }: {
+export default function BlastPanel({ handleClose, model, feature, preferredTranscriptId, }: {
     handleClose: () => void;
     model: AbstractTrackModel;
     feature: Feature;
+    /** the isoform the user right-clicked, preselected in the picker */
+    preferredTranscriptId?: string;
 }): React.JSX.Element;
 export {};

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

@@ -1,6 +1,6 @@
 import React, { useState } from 'react';
 import SettingsIcon from '@mui/icons-material/Settings';
-import { IconButton } from '@mui/material';
+import { IconButton, Tooltip } from '@mui/material';
 import { makeStyles } from 'tss-react/mui';
 import { DEFAULT_EBI_EMAIL, EBI_EMAIL_STORAGE_KEY, } from '../../../utils/ebiJobDispatcher';
 import { useLocalStorage } from '../../../utils/useLocalStorage';
@@ -17,18 +17,19 @@ const panelMap = {
     automatic: BlastAutomaticPanel,
     manual: BlastManualPanel,
 };
-export default function BlastPanel({ handleClose, model, feature, }) {
+export default function BlastPanel({ handleClose, model, feature, preferredTranscriptId, }) {
     const [lookupMethod, setLookupMethod] = useState('automatic');
     const [ebiEmail, setEbiEmail] = useLocalStorage(EBI_EMAIL_STORAGE_KEY, DEFAULT_EBI_EMAIL);
     const [settingsOpen, setSettingsOpen] = useState(false);
     const { classes } = useStyles();
     const Panel = panelMap[lookupMethod];
     return (React.createElement(React.Fragment, null,
-        React.createElement(IconButton, { className: classes.settingsButton, size: "small", onClick: () => {
-                setSettingsOpen(true);
-            } },
-            React.createElement(SettingsIcon, null)),
-        React.createElement(Panel, { model: model, feature: feature, handleClose: handleClose },
+        React.createElement(Tooltip, { title: `EBI settings — jobs are submitted with ${ebiEmail}` },
+            React.createElement(IconButton, { className: classes.settingsButton, "aria-label": "EBI settings", size: "small", onClick: () => {
+                    setSettingsOpen(true);
+                } },
+                React.createElement(SettingsIcon, null))),
+        React.createElement(Panel, { model: model, feature: feature, handleClose: handleClose, preferredTranscriptId: preferredTranscriptId },
             React.createElement(BlastMethodSelector, { lookupMethod: lookupMethod, setLookupMethod: setLookupMethod })),
         settingsOpen ? (React.createElement(BlastSettingsDialog, { ebiEmail: ebiEmail, handleClose: settings => {
                 if (settings) {

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

@@ -17,9 +17,9 @@ export default function BlastSettingsDialog({ handleClose, ebiEmail, }) {
     return (React.createElement(Dialog, { open: true, maxWidth: "lg", onClose: () => {
             handleClose();
         } },
-        React.createElement(DialogTitle, null, "BLAST Settings"),
+        React.createElement(DialogTitle, null, "EBI settings"),
         React.createElement(DialogContent, null,
-            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(Typography, { variant: "subtitle2", className: classes.help }, "Every search this tab runs is submitted to EBI with this address, which is how they 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);
                 } }),

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

@@ -1,9 +1,11 @@
 import React from 'react';
 import { MenuItem } from '@mui/material';
 import TextField2 from '../../../components/TextField2';
-import { msaAlgorithms } from './consts';
+import { msaAlgorithmLabels, msaAlgorithms } from './consts';
 export default function MsaAlgorithmSelect({ value, onChange, className, }) {
-    return (React.createElement(TextField2, { variant: "outlined", label: "MSA Algorithm", className: className, select: true, value: value, onChange: event => {
+    return (React.createElement(TextField2, { variant: "outlined", label: "MSA Algorithm", className: className, select: true, value: value, helperText: value === 'browser'
+            ? 'no EBI job; rows aligned to the query'
+            : undefined, onChange: event => {
             onChange(event.target.value);
-        } }, msaAlgorithms.map(val => (React.createElement(MenuItem, { value: val, key: val }, val)))));
+        } }, msaAlgorithms.map(val => (React.createElement(MenuItem, { value: val, key: val }, msaAlgorithmLabels[val])))));
 }

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

@@ -5,8 +5,20 @@
  * 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"];
+/** The aligners EBI's Job Dispatcher runs, each a tool name at their REST api. */
+export declare const ebiMsaAlgorithms: readonly ["clustalo", "muscle", "kalign", "mafft"];
+export type EbiMsaAlgorithm = (typeof ebiMsaAlgorithms)[number];
+/**
+ * `browser` is no job at all: each sequence is aligned to the query in the
+ * page and the rows merged on the query (utils/browserAlign.ts), with the tree
+ * built by react-msaview's neighbour joining. It is the aligner for a launch
+ * that must not depend on EBI, and for one that wants to be quick -- a
+ * hundred rows take a second or two against a Job Dispatcher queue that has
+ * been measured at anything from ten seconds to fifteen minutes.
+ */
+export declare const msaAlgorithms: readonly ["clustalo", "muscle", "kalign", "mafft", "browser"];
 export type MsaAlgorithm = (typeof msaAlgorithms)[number];
+export declare const msaAlgorithmLabels: Record<MsaAlgorithm, string>;
 /**
  * EBI rejects a submission naming a database outside its own list with a 400,
  * so every value here has to appear in
@@ -19,15 +31,24 @@ export type BlastDatabase = (typeof blastDatabaseOptions)[number];
 export declare const defaultBlastDatabase: BlastDatabase;
 export declare const searchPrograms: readonly ["blastp", "phmmer"];
 export type SearchProgram = (typeof searchPrograms)[number];
+export declare const searchProgramLabels: Record<SearchProgram, string>;
 /**
  * phmmer offers PDB, AlphaFold, Ensembl Genomes, MEROPS and ChEMBL too, but
- * targets outside UniProt carry no OS=/OX= in their description, so those rows
+ * targets outside UniProt carry no species in their description, so those rows
  * would lose their species and common name. Only the databases that label their
  * hits are offered.
+ *
+ * rp15..rp75 are the Representative Proteomes: UniProt's reference proteomes
+ * thinned so that no two are more than 15% (35%, 55%, 75%) similar, which is
+ * the widest taxonomic spread per hit that any of these databases gives. rp15
+ * is the one to reach for when the question is "what is this like across all
+ * of life"; swissprot when it is "what is this like in the curated set".
  */
-export declare const phmmerDatabaseOptions: readonly ["swissprot", "uniprotkb", "uniprotrefprot"];
+export declare const phmmerDatabaseOptions: readonly ["swissprot", "uniprotkb", "uniprotrefprot", "rp75", "rp55", "rp35", "rp15"];
 export type PhmmerDatabase = (typeof phmmerDatabaseOptions)[number];
 export declare const defaultPhmmerDatabase: PhmmerDatabase;
+export declare const defaultMaxHits = 100;
+export declare function snapBlastHitCount(maxHits: number): number;
 /**
  * A program together with a database that program actually has.
  *
@@ -44,4 +65,5 @@ export type SearchChoice = {
     database: PhmmerDatabase;
 };
 export declare function defaultSearchFor(program: SearchProgram): SearchChoice;
-export declare function databaseOptionsFor(program: SearchProgram): readonly ["uniprotkb_swissprot", "uniprotkb", "pan_proteomes", "uniprotkb_trembl"] | readonly ["swissprot", "uniprotkb", "uniprotrefprot"];
+export declare function databaseOptionsFor(program: SearchProgram): readonly ["uniprotkb_swissprot", "uniprotkb", "pan_proteomes", "uniprotkb_trembl"] | readonly ["swissprot", "uniprotkb", "uniprotrefprot", "rp75", "rp55", "rp35", "rp15"];
+export declare function databaseLabel(database: BlastDatabase | PhmmerDatabase): string;

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

@@ -5,7 +5,29 @@
  * 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'];
+/** The aligners EBI's Job Dispatcher runs, each a tool name at their REST api. */
+export const ebiMsaAlgorithms = [
+    'clustalo',
+    'muscle',
+    'kalign',
+    'mafft',
+];
+/**
+ * `browser` is no job at all: each sequence is aligned to the query in the
+ * page and the rows merged on the query (utils/browserAlign.ts), with the tree
+ * built by react-msaview's neighbour joining. It is the aligner for a launch
+ * that must not depend on EBI, and for one that wants to be quick -- a
+ * hundred rows take a second or two against a Job Dispatcher queue that has
+ * been measured at anything from ten seconds to fifteen minutes.
+ */
+export const msaAlgorithms = [...ebiMsaAlgorithms, 'browser'];
+export const msaAlgorithmLabels = {
+    clustalo: 'Clustal Omega (EBI)',
+    muscle: 'MUSCLE (EBI)',
+    kalign: 'Kalign (EBI)',
+    mafft: 'MAFFT (EBI)',
+    browser: 'in browser, query-anchored',
+};
 /**
  * EBI rejects a submission naming a database outside its own list with a 400,
  * so every value here has to appear in
@@ -23,18 +45,42 @@ export const blastDatabaseOptions = [
 // many near-identical TrEMBL entries an alignment reads poorly
 export const defaultBlastDatabase = 'uniprotkb_swissprot';
 export const searchPrograms = ['blastp', 'phmmer'];
+export const searchProgramLabels = {
+    blastp: 'blastp (sequence search)',
+    phmmer: 'phmmer (profile HMM search)',
+};
 /**
  * phmmer offers PDB, AlphaFold, Ensembl Genomes, MEROPS and ChEMBL too, but
- * targets outside UniProt carry no OS=/OX= in their description, so those rows
+ * targets outside UniProt carry no species in their description, so those rows
  * would lose their species and common name. Only the databases that label their
  * hits are offered.
+ *
+ * rp15..rp75 are the Representative Proteomes: UniProt's reference proteomes
+ * thinned so that no two are more than 15% (35%, 55%, 75%) similar, which is
+ * the widest taxonomic spread per hit that any of these databases gives. rp15
+ * is the one to reach for when the question is "what is this like across all
+ * of life"; swissprot when it is "what is this like in the curated set".
  */
 export const phmmerDatabaseOptions = [
     'swissprot',
     'uniprotkb',
     'uniprotrefprot',
+    'rp75',
+    'rp55',
+    'rp35',
+    'rp15',
 ];
 export const defaultPhmmerDatabase = 'swissprot';
+/**
+ * The hit counts EBI's ncbiblast accepts for `alignments` and `scores`. A value
+ * off this list is a 400 at submit time, so a request is rounded up to the next
+ * one on it.
+ */
+const blastHitCounts = [5, 10, 20, 50, 100, 150, 200, 250, 500, 750, 1000];
+export const defaultMaxHits = 100;
+export function snapBlastHitCount(maxHits) {
+    return blastHitCounts.find(n => n >= maxHits) ?? blastHitCounts.at(-1);
+}
 export function defaultSearchFor(program) {
     return program === 'phmmer'
         ? { program, database: defaultPhmmerDatabase }
@@ -43,3 +89,23 @@ export function defaultSearchFor(program) {
 export function databaseOptionsFor(program) {
     return program === 'phmmer' ? phmmerDatabaseOptions : blastDatabaseOptions;
 }
+/**
+ * What each database is called in the menu. The keys are what EBI is sent and
+ * are not negotiable; `uniprotkb_swissprot` and `swissprot` are the same
+ * collection under each service's own name, so they read the same here.
+ */
+const databaseLabels = {
+    uniprotkb_swissprot: 'UniProtKB/Swiss-Prot (curated)',
+    swissprot: 'UniProtKB/Swiss-Prot (curated)',
+    uniprotkb: 'UniProtKB (all entries)',
+    uniprotkb_trembl: 'UniProtKB/TrEMBL (unreviewed)',
+    pan_proteomes: 'Pan-proteomes',
+    uniprotrefprot: 'UniProt reference proteomes',
+    rp75: 'Representative proteomes, 75%',
+    rp55: 'Representative proteomes, 55%',
+    rp35: 'Representative proteomes, 35%',
+    rp15: 'Representative proteomes, 15% (widest spread)',
+};
+export function databaseLabel(database) {
+    return databaseLabels[database];
+}