jbrowse-plugin-msaview 2.7.3 → 2.7.4

package/dist/utils/ncbiOrthologs.d.ts

@@ -0,0 +1,105 @@
+export declare const COMMON_SPECIES: readonly [{
+    readonly label: "Human";
+    readonly taxId: 9606;
+}, {
+    readonly label: "Mouse";
+    readonly taxId: 10090;
+}, {
+    readonly label: "Rat";
+    readonly taxId: 10116;
+}, {
+    readonly label: "Cow";
+    readonly taxId: 9913;
+}, {
+    readonly label: "Pig";
+    readonly taxId: 9823;
+}, {
+    readonly label: "Dog";
+    readonly taxId: 9615;
+}, {
+    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,211 @@
+// 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.
+export const COMMON_SPECIES = [
+    { label: 'Human', taxId: 9606 },
+    { label: 'Mouse', taxId: 10090 },
+    { label: 'Rat', taxId: 10116 },
+    { label: 'Cow', taxId: 9913 },
+    { label: 'Pig', taxId: 9823 },
+    { label: 'Dog', taxId: 9615 },
+    { 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.7.4";

package/dist/version.js

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.7.3",
+  "version": "2.7.4",
   "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,
+  },
+  speciesBox: {
+    display: 'flex',
+    flexWrap: 'wrap',
+    maxWidth: 560,
+    marginTop: 12,
+  },
+  species: {
+    width: 160,
+  },
+  infoText: {
+    marginTop: 20,
+    maxWidth: 620,
+  },
+})
+
+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}>
+        <Typography>
+          Builds the alignment from NCBI&apos;s precomputed orthologs — one gene
+          per species — instead of searching. There is no job to wait on: the
+          NCBI lookups take about a second, and only the multiple alignment at
+          EBI costs real time (~10s), against 10+ minutes for BLAST. Rows come
+          out labelled by species rather than by accession, and NCBI&apos;s CDD
+          domains are overlaid automatically.
+        </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: 12 }}>
+          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} />
+
+        <Typography className={classes.infoText} variant="body2">
+          The query row is the transcript selected above, not NCBI&apos;s
+          representative protein, so the alignment stays linked to the genome
+          view at codon resolution.
+        </Typography>
+      </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

package/src/LaunchMsaView/components/OrthologQuery/orthologLaunchView.ts

@@ -0,0 +1,28 @@
+import { getSession } from '@jbrowse/core/util'
+
+import type { OrthologParams } from '../../../MsaViewPanel/model'
+import type { Feature } from '@jbrowse/core/util'
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
+
+export function orthologLaunchView({
+  newViewTitle,
+  view,
+  feature,
+  orthologParams,
+}: {
+  newViewTitle: string
+  view: LinearGenomeViewModel
+  feature: Feature
+  orthologParams: OrthologParams
+}) {
+  getSession(view).addView('MsaView', {
+    type: 'MsaView',
+    displayName: newViewTitle,
+    connectedViewId: view.id,
+    connectedFeature: feature.toJSON(),
+    drawNodeBubbles: true,
+    colWidth: 10,
+    rowHeight: 12,
+    orthologParams,
+  })
+}

package/src/MsaViewPanel/afterCreateAutoruns.ts

@@ -1,6 +1,7 @@
 import { getSession } from '@jbrowse/core/util'
 
 import { doLaunchBlast } from './doLaunchBlast'
+import { doLaunchOrthologs } from './doLaunchOrthologs'
 import { fetchIndexedMsa } from './fetchIndexedMsa'
 import { genomeToMSA } from './genomeToMSA'
 import { loadProteinDomains } from './loadProteinDomains'
@@ -78,6 +79,32 @@ export function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel) {
   }
 }
 
+/**
+ * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
+ * request, and clearing them on success is what marks it done. They are left in
+ * place on failure so the error stays attributable to a specific request; the
+ * autorun's only tracked read is orthologParams itself, so nothing refires
+ * until a new request replaces them.
+ */
+export function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel) {
+  if (self.orthologParams) {
+    void (async () => {
+      try {
+        self.setProgress('Resolving orthologs')
+        self.setError(undefined)
+        const data = await doLaunchOrthologs({ self })
+        self.setData(data)
+        self.setOrthologParams(undefined)
+      } catch (e) {
+        self.setError(e)
+        console.error(e)
+      } finally {
+        self.setProgress('')
+      }
+    })()
+  }
+}
+
 export function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel) {
   if (self.blastParams) {
     void (async () => {