jbrowse-plugin-msaview 2.7.3 → 2.8.0

package/dist/utils/ncbiOrthologs.d.ts

@@ -0,0 +1,135 @@
+export declare const COMMON_SPECIES: readonly [{
+    readonly label: "Human";
+    readonly taxId: 9606;
+}, {
+    readonly label: "Chimpanzee";
+    readonly taxId: 9598;
+}, {
+    readonly label: "Gorilla";
+    readonly taxId: 9595;
+}, {
+    readonly label: "Rhesus macaque";
+    readonly taxId: 9544;
+}, {
+    readonly label: "Marmoset";
+    readonly taxId: 9483;
+}, {
+    readonly label: "Mouse";
+    readonly taxId: 10090;
+}, {
+    readonly label: "Rat";
+    readonly taxId: 10116;
+}, {
+    readonly label: "Guinea pig";
+    readonly taxId: 10141;
+}, {
+    readonly label: "Rabbit";
+    readonly taxId: 9986;
+}, {
+    readonly label: "Cat";
+    readonly taxId: 9685;
+}, {
+    readonly label: "Dog";
+    readonly taxId: 9615;
+}, {
+    readonly label: "Horse";
+    readonly taxId: 9796;
+}, {
+    readonly label: "Pig";
+    readonly taxId: 9823;
+}, {
+    readonly label: "Cow";
+    readonly taxId: 9913;
+}, {
+    readonly label: "Sheep";
+    readonly taxId: 9940;
+}, {
+    readonly label: "Opossum";
+    readonly taxId: 13616;
+}, {
+    readonly label: "Chicken";
+    readonly taxId: 9031;
+}, {
+    readonly label: "Frog";
+    readonly taxId: 8364;
+}, {
+    readonly label: "Zebrafish";
+    readonly taxId: 7955;
+}, {
+    readonly label: "Fruitfly";
+    readonly taxId: 7227;
+}, {
+    readonly label: "C. elegans";
+    readonly taxId: 6239;
+}, {
+    readonly label: "Yeast";
+    readonly taxId: 4932;
+}, {
+    readonly label: "Arabidopsis";
+    readonly taxId: 3702;
+}];
+export declare const COMMON_TAX_RANK: Map<number, number>;
+export interface OrthologRow {
+    taxId: number;
+    /** single-token id used identically in the FASTA, the tree and the domain GFF */
+    label: string;
+    scientificName: string;
+    commonName?: string;
+    geneId: string;
+    /** accession.version */
+    protein: string;
+    sequence: string;
+}
+/**
+ * A free-text gene reference -> NCBI gene id. A bare number is taken as the id
+ * itself; anything else is searched as a gene name within the query taxon.
+ * Several candidate identifiers are tried in order, because a JBrowse feature
+ * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
+ * some of those are real symbols.
+ */
+export declare function resolveGeneId(candidates: string[], taxId: number): Promise<{
+    geneId: string;
+    matched: string;
+} | undefined>;
+/** One ortholog gene per species, restricted to the requested taxa. */
+export declare function fetchOrthologGenes(geneId: string, taxa: Set<number>): Promise<{
+    taxId: number;
+    geneId: string;
+    scientificName: string;
+    commonName?: string;
+}[]>;
+/**
+ * geneId -> representative protein accession: MANE Select where flagged, else
+ * the longest isoform. A stable, comparable choice across species — picking
+ * "the first" would silently vary with NCBI's ordering.
+ */
+export declare function fetchRepresentativeProteins(geneIds: string[]): Promise<Map<string, string>>;
+/** accession (first header token) -> ungapped sequence, from a multi-FASTA. */
+export declare function parseFasta(text: string): Map<string, string>;
+/**
+ * Sanitized, unique single-token labels used identically in the FASTA headers,
+ * the tree leaf names and the domain GFF seq_ids — that identity is how the
+ * viewer pairs a tree leaf to its alignment row to its domain track. Collisions
+ * get a numeric suffix rather than silently overwriting a row.
+ */
+export declare function dedupeLabels(names: string[]): string[];
+/**
+ * The representative protein for a single gene, with its sequence. Used to
+ * decide whether the user's own translated transcript is byte-identical to the
+ * RefSeq protein — if it is, that accession's precomputed CDD domains apply to
+ * the query row exactly, and if it isn't, they would land at an offset.
+ */
+export declare function fetchProteinForGene(geneId: string): Promise<{
+    accession: string;
+    sequence: string;
+} | undefined>;
+/**
+ * The whole NCBI half of the pipeline: gene -> ortholog rows carrying labels,
+ * accessions and sequences. Everything here is a precomputed lookup, so this
+ * returns in seconds rather than the 10+ minutes a BLAST submission costs.
+ */
+export declare function fetchOrthologRows({ geneId, taxa, onProgress, }: {
+    geneId: string;
+    taxa: Set<number>;
+    onProgress: (arg: string) => void;
+}): Promise<OrthologRow[]>;

package/dist/utils/ncbiOrthologs.js

@@ -0,0 +1,241 @@
+// Homolog discovery WITHOUT a search job.
+//
+// The BLAST path answers "what looks like this sequence", which is not the
+// question an MSA row set wants — it wants "what is homologous to this gene,
+// one per species, labelled by species". BLAST then costs 10+ minutes to
+// return a redundant, accession-labelled hit list that has to be deduplicated
+// before it reads. NCBI has already computed the answer: the Datasets
+// orthologs endpoint returns one ortholog gene per species, instantly.
+//
+// gene symbol -> gene id -> orthologs -> a representative protein each ->
+// sequences, all from NCBI, in a handful of requests. The caller aligns them
+// (EBI Clustal Omega, ~10s) and overlays CDD domains, which are already baked
+// into the GenPept records (see ncbiDomains.ts).
+//
+// Mirrors jb2hubs' website/src/components/proteinMsa.ts assembler, trimmed to
+// what the launch dialog needs and using this plugin's fetch/eutils helpers.
+import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
+import { jsonfetch, textfetch } from './fetch';
+// v2, not v2alpha: the alpha path still answers /orthologs but 404s
+// /product_report, so an assembler pointed at it silently resolves zero
+// representative proteins and reports "no orthologs" for every gene.
+const DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2';
+const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+// The species panel offered in the launch dialog, ordered from the reference
+// outward so a run that finds only close relatives still reads as a ladder.
+// Orthologs absent for a given gene are skipped rather than erroring, and the
+// index order here is the ROW order of the alignment (COMMON_TAX_RANK below).
+//
+// THE MAMMALS EARN THEIR PLACE, and the reason is measured rather than aesthetic.
+// The thirteen this list used to hold were one per major clade, which reads well
+// on a gene conserved to yeast and produces almost nothing on a gene that is not:
+// NCBI publishes 165 orthologs for human NLRP1 and every one of them is a mammal,
+// so of the old thirteen only Human, Mouse, Cow, Pig and Dog returned a row --
+// five, and Rat not among them, since NLRP1 is absent in Rattus norvegicus. The
+// same query against this list returns twelve. An inflammasome gene is not an
+// unusual case; anything immune, reproductive or lineage-specific behaves the
+// same way, and those are the genes a person opens an ortholog alignment on.
+//
+// Cat, rabbit and opossum are here despite contributing nothing to that gene.
+// They are the three that most often separate "absent in this clade" from
+// "absent in this species", which is the question a gap in the alignment raises.
+//
+// The cost is the run, and it is roughly linear: one NCBI protein fetch per
+// species and a Clustal Omega job over what comes back, so ~23 rows is about
+// twice the ~13-row wait. Still seconds rather than the minutes BLAST takes,
+// which is the comparison the panel's own text makes.
+export const COMMON_SPECIES = [
+    { label: 'Human', taxId: 9606 },
+    { label: 'Chimpanzee', taxId: 9598 },
+    { label: 'Gorilla', taxId: 9595 },
+    { label: 'Rhesus macaque', taxId: 9544 },
+    { label: 'Marmoset', taxId: 9483 },
+    { label: 'Mouse', taxId: 10090 },
+    { label: 'Rat', taxId: 10116 },
+    { label: 'Guinea pig', taxId: 10141 },
+    { label: 'Rabbit', taxId: 9986 },
+    { label: 'Cat', taxId: 9685 },
+    { label: 'Dog', taxId: 9615 },
+    { label: 'Horse', taxId: 9796 },
+    { label: 'Pig', taxId: 9823 },
+    { label: 'Cow', taxId: 9913 },
+    { label: 'Sheep', taxId: 9940 },
+    { label: 'Opossum', taxId: 13616 },
+    { label: 'Chicken', taxId: 9031 },
+    { label: 'Frog', taxId: 8364 },
+    { label: 'Zebrafish', taxId: 7955 },
+    { label: 'Fruitfly', taxId: 7227 },
+    { label: 'C. elegans', taxId: 6239 },
+    { label: 'Yeast', taxId: 4932 },
+    { label: 'Arabidopsis', taxId: 3702 },
+];
+export const COMMON_TAX_RANK = new Map(COMMON_SPECIES.map((s, i) => [s.taxId, i]));
+function ncbiUrl(url) {
+    const sep = url.includes('?') ? '&' : '?';
+    return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
+}
+/**
+ * A free-text gene reference -> NCBI gene id. A bare number is taken as the id
+ * itself; anything else is searched as a gene name within the query taxon.
+ * Several candidate identifiers are tried in order, because a JBrowse feature
+ * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
+ * some of those are real symbols.
+ */
+export async function resolveGeneId(candidates, taxId) {
+    for (const raw of candidates) {
+        const query = raw.trim();
+        if (!query) {
+            continue;
+        }
+        if (/^\d+$/.test(query)) {
+            return { geneId: query, matched: query };
+        }
+        // strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53)
+        const cleaned = query.replace(/^\w+:/, '').replace(/\.\d+$/, '');
+        const term = `${cleaned}[Gene Name] AND ${taxId}[taxid]`;
+        const json = await jsonfetch(ncbiUrl(`${EUTILS}/esearch.fcgi?db=gene&term=${encodeURIComponent(term)}&retmode=json&retmax=1`));
+        const geneId = json.esearchresult?.idlist?.[0];
+        if (geneId) {
+            return { geneId, matched: cleaned };
+        }
+    }
+    return undefined;
+}
+/** One ortholog gene per species, restricted to the requested taxa. */
+export async function fetchOrthologGenes(geneId, taxa) {
+    const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`));
+    const byTaxon = new Map();
+    for (const { gene } of json.reports ?? []) {
+        const taxId = Number(gene?.tax_id);
+        if (gene?.gene_id && taxa.has(taxId) && !byTaxon.has(taxId)) {
+            byTaxon.set(taxId, {
+                taxId,
+                geneId: gene.gene_id,
+                scientificName: gene.taxname ?? String(taxId),
+                commonName: gene.common_name,
+            });
+        }
+    }
+    return [...byTaxon.values()].sort((a, b) => (COMMON_TAX_RANK.get(a.taxId) ?? Infinity) -
+        (COMMON_TAX_RANK.get(b.taxId) ?? Infinity));
+}
+/**
+ * geneId -> representative protein accession: MANE Select where flagged, else
+ * the longest isoform. A stable, comparable choice across species — picking
+ * "the first" would silently vary with NCBI's ordering.
+ */
+export async function fetchRepresentativeProteins(geneIds) {
+    const byGene = new Map();
+    if (geneIds.length > 0) {
+        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneIds.join(',')}/product_report`));
+        for (const { product } of json.reports ?? []) {
+            const candidates = (product?.transcripts ?? [])
+                .map(t => ({
+                acc: t.protein?.accession_version,
+                len: t.protein?.length ?? 0,
+                mane: /select/i.test(t.select_category ?? ''),
+            }))
+                .filter((c) => !!c.acc);
+            const best = candidates.find(c => c.mane) ??
+                [...candidates].sort((a, b) => b.len - a.len).at(0);
+            if (product?.gene_id && best) {
+                byGene.set(product.gene_id, best.acc);
+            }
+        }
+    }
+    return byGene;
+}
+/** accession (first header token) -> ungapped sequence, from a multi-FASTA. */
+export function parseFasta(text) {
+    const map = new Map();
+    let acc;
+    let buf = [];
+    for (const line of text.split('\n')) {
+        if (line.startsWith('>')) {
+            if (acc) {
+                map.set(acc, buf.join(''));
+            }
+            acc = line.slice(1).split(/\s+/)[0];
+            buf = [];
+        }
+        else {
+            buf.push(line.trim());
+        }
+    }
+    if (acc) {
+        map.set(acc, buf.join(''));
+    }
+    return map;
+}
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+/**
+ * Sanitized, unique single-token labels used identically in the FASTA headers,
+ * the tree leaf names and the domain GFF seq_ids — that identity is how the
+ * viewer pairs a tree leaf to its alignment row to its domain track. Collisions
+ * get a numeric suffix rather than silently overwriting a row.
+ */
+export function dedupeLabels(names) {
+    const seen = new Map();
+    return names.map(name => {
+        const base = sanitize(name) || 'row';
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        return n === 0 ? base : `${base}_${n + 1}`;
+    });
+}
+/**
+ * The representative protein for a single gene, with its sequence. Used to
+ * decide whether the user's own translated transcript is byte-identical to the
+ * RefSeq protein — if it is, that accession's precomputed CDD domains apply to
+ * the query row exactly, and if it isn't, they would land at an offset.
+ */
+export async function fetchProteinForGene(geneId) {
+    const acc = (await fetchRepresentativeProteins([geneId])).get(geneId);
+    if (!acc) {
+        return undefined;
+    }
+    const seq = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${acc}&rettype=fasta&retmode=text`))).get(acc);
+    return seq ? { accession: acc, sequence: seq } : undefined;
+}
+/**
+ * The whole NCBI half of the pipeline: gene -> ortholog rows carrying labels,
+ * accessions and sequences. Everything here is a precomputed lookup, so this
+ * returns in seconds rather than the 10+ minutes a BLAST submission costs.
+ */
+export async function fetchOrthologRows({ geneId, taxa, onProgress, }) {
+    onProgress('Finding orthologs across species...');
+    const genes = await fetchOrthologGenes(geneId, taxa);
+    if (genes.length < 2) {
+        throw new Error(`Only ${genes.length} ortholog(s) found among the selected species — not enough to align`);
+    }
+    onProgress('Selecting a representative protein per species...');
+    const proteinByGene = await fetchRepresentativeProteins(genes.map(g => g.geneId));
+    const withProtein = genes.filter(g => proteinByGene.has(g.geneId));
+    if (withProtein.length < 2) {
+        throw new Error('Could not resolve representative proteins for the orthologs');
+    }
+    onProgress(`Fetching ${withProtein.length} protein sequences...`);
+    const accessions = withProtein.map(g => proteinByGene.get(g.geneId));
+    const seqByAcc = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${accessions.join(',')}&rettype=fasta&retmode=text`)));
+    const labels = dedupeLabels(withProtein.map(g => g.commonName ?? g.scientificName));
+    const rows = withProtein
+        .map((g, i) => {
+        const protein = proteinByGene.get(g.geneId);
+        return {
+            taxId: g.taxId,
+            label: labels[i],
+            scientificName: g.scientificName,
+            commonName: g.commonName,
+            geneId: g.geneId,
+            protein,
+            sequence: seqByAcc.get(protein) ?? '',
+        };
+    })
+        .filter(r => r.sequence);
+    if (rows.length < 2) {
+        throw new Error('Could not fetch protein sequences for the orthologs');
+    }
+    return rows;
+}

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

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

package/dist/utils/ncbiOrthologs.test.js

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

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.7.3";
+export declare const version = "2.8.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.7.3';
+export const version = '2.8.0';

package/package.json

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

package/src/LaunchMsaView/components/LaunchMsaViewDialog.tsx

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

package/src/LaunchMsaView/components/OrthologQuery/OrthologPanel.tsx

@@ -0,0 +1,172 @@
+import React, { useMemo, useState } from 'react'
+
+import { Checkbox, FormControlLabel, MenuItem, Typography } from '@mui/material'
+import { observer } from 'mobx-react'
+import { makeStyles } from 'tss-react/mui'
+
+import { orthologLaunchView } from './orthologLaunchView'
+import TextField2 from '../../../components/TextField2'
+import { COMMON_SPECIES } from '../../../utils/ncbiOrthologs'
+import {
+  getGeneDisplayName,
+  getGeneIdentifiers,
+  getLinearGenomeView,
+  getTranscriptDisplayName,
+} from '../../util'
+import LaunchPanelContent from '../LaunchPanelContent'
+import MsaAlgorithmSelect from '../NCBIBlastQuery/MsaAlgorithmSelect'
+import SubmitCancelActions from '../SubmitCancelActions'
+import TranscriptSelector from '../TranscriptSelector'
+import { useTranscriptSelection } from '../useTranscriptSelection'
+
+import type { MsaAlgorithm } from '../NCBIBlastQuery/consts'
+import type { AbstractTrackModel, Feature } from '@jbrowse/core/util'
+
+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,
+}: {
+  model: AbstractTrackModel
+  feature: Feature
+  handleClose: () => void
+}) {
+  const { classes } = useStyles()
+  const view = getLinearGenomeView(model)
+  const [launchViewError, setLaunchViewError] = useState<unknown>()
+  const [taxId, setTaxId] = useState(9606)
+  const [msaAlgorithm, setMsaAlgorithm] = useState<MsaAlgorithm>('clustalo')
+  const [excluded, setExcluded] = useState<number[]>([])
+
+  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),
+  )
+
+  return (
+    <>
+      <LaunchPanelContent error={e}>
+        {/* One line rather than seven. What a reader needs here is which tab
+            to pick, and that is the seconds-against-minutes comparison; the
+            rest (species labels, CDD overlay, the query row being the selected
+            transcript) is visible in the result or documented, and as prose it
+            was most of the dialog's height. */}
+        <Typography variant="body2">
+          NCBI&apos;s precomputed orthologs, one gene per species, aligned at EBI
+          in seconds rather than the 10+ minutes BLAST takes.
+        </Typography>
+
+        <div>
+          <TextField2
+            variant="outlined"
+            label="Query species"
+            className={classes.selectField}
+            select
+            value={taxId}
+            onChange={event => {
+              setTaxId(Number(event.target.value))
+            }}
+            helperText="the species this gene is from"
+          >
+            {COMMON_SPECIES.map(s => (
+              <MenuItem value={s.taxId} key={s.taxId}>
+                {s.label}
+              </MenuItem>
+            ))}
+          </TextField2>
+
+          <MsaAlgorithmSelect
+            className={classes.selectField}
+            value={msaAlgorithm}
+            onChange={setMsaAlgorithm}
+          />
+        </div>
+
+        <Typography variant="subtitle2" style={{ marginTop: 8 }}>
+          Species to include (those without an ortholog are skipped)
+        </Typography>
+        <div className={classes.speciesBox}>
+          {COMMON_SPECIES.map(s => (
+            <FormControlLabel
+              className={classes.species}
+              key={s.taxId}
+              control={
+                <Checkbox
+                  checked={!excluded.includes(s.taxId)}
+                  onChange={event => {
+                    setExcluded(
+                      event.target.checked
+                        ? excluded.filter(t => t !== s.taxId)
+                        : [...excluded, s.taxId],
+                    )
+                  }}
+                />
+              }
+              label={s.label}
+            />
+          ))}
+        </div>
+
+        <TranscriptSelector feature={feature} {...transcriptSelection} />
+
+      </LaunchPanelContent>
+      <SubmitCancelActions
+        submitDisabled={!proteinSequence || taxa.length < 2}
+        onSubmit={() => {
+          try {
+            if (selectedTranscript) {
+              setLaunchViewError(undefined)
+              orthologLaunchView({
+                feature: selectedTranscript,
+                view,
+                newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
+                orthologParams: {
+                  taxId,
+                  taxa,
+                  geneCandidates,
+                  msaAlgorithm,
+                  selectedTranscript,
+                  proteinSequence,
+                },
+              })
+              handleClose()
+            }
+          } catch (e) {
+            console.error(e)
+            setLaunchViewError(e)
+          }
+        }}
+        onCancel={handleClose}
+      />
+    </>
+  )
+})
+
+export default OrthologPanel