jbrowse-plugin-msaview 2.9.0 → 2.10.0

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

@@ -1,12 +1,13 @@
 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,
@@ -26,23 +27,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 ({
@@ -59,86 +43,64 @@ const OrthologPanel = observer(function ({
   const [launchViewError, setLaunchViewError] = useState<unknown>()
   const [taxId, setTaxId] = useState(9606)
   const [msaAlgorithm, setMsaAlgorithm] = useState<MsaAlgorithm>('clustalo')
-  const [excluded, setExcluded] = useState<number[]>([])
+  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 (
     <>
       <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. */}
+        {/* One line rather than seven. What a reader needs here is which tab to
+            pick; 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.
+
+            The comparison stays but the number moved: the lookup is still
+            instant, and it is now the aligner that costs the wait, about half a
+            second per row. */}
         <Typography variant="body2">
-          NCBI&apos;s precomputed orthologs, one gene per species, aligned at EBI
-          in seconds rather than the 10+ minutes BLAST takes.
+          NCBI&apos;s precomputed orthologs, one gene per species, looked up
+          rather than searched for. No BLAST job to queue.
         </Typography>
 
         <div>
-          <TextField2
-            variant="outlined"
-            label="Query species"
+          <QuerySpeciesSelect
             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>
+            onChange={setTaxId}
+          />
 
           <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}
-            />
-          ))}
+          <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"
+          />
         </div>
 
         <TranscriptSelector feature={feature} {...transcriptSelection} />
 
       </LaunchPanelContent>
       <SubmitCancelActions
-        submitDisabled={!proteinSequence || taxa.length < 2}
+        submitDisabled={!proteinSequence || !rowCountValid}
         onSubmit={() => {
           try {
             if (selectedTranscript) {
@@ -149,7 +111,7 @@ const OrthologPanel = observer(function ({
                 newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
                 orthologParams: {
                   taxId,
-                  taxa,
+                  maxSpecies: rowCount,
                   geneCandidates,
                   msaAlgorithm,
                   selectedTranscript,

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

@@ -0,0 +1,92 @@
+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,
+}: {
+  value: number
+  onChange: (taxId: number) => void
+  className?: string
+}) {
+  const [text, setText] = useState('human')
+  const [resolved, setResolved] = useState<string>()
+  const [error, setError] = useState<unknown>()
+
+  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 (
+    <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/src/LaunchMsaView/index.ts

@@ -26,7 +26,6 @@ interface ContextMenuInfo {
 interface DisplayModel {
   contextMenuItems: () => MenuItem[]
   contextMenuInfo?: ContextMenuInfo
-  isGeneLike?: boolean
   fetchFullFeature?: (
     featureId: string,
     displayedRegionIndex: number,
@@ -34,6 +33,25 @@ interface DisplayModel {
   contextMenuFeature?: Feature
 }
 
+// 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: string | undefined) {
+  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: IAnyModelType) {
@@ -54,7 +72,7 @@ function extendStateModel(stateModel: IAnyModelType) {
         const fetchFullFeature = self.fetchFullFeature
         const legacyFeature = self.contextMenuFeature
         const onClick =
-          info && fetchFullFeature && self.isGeneLike
+          info && fetchFullFeature && isGeneLikeType(info.item.type)
             ? () => {
                 fetchFullFeature(info.item.featureId, info.displayedRegionIndex)
                   .then(feature => {

package/src/MsaViewPanel/doLaunchOrthologs.test.ts

@@ -3,20 +3,21 @@ import { beforeEach, describe, expect, test, vi } from 'vitest'
 import { doLaunchOrthologs } from './doLaunchOrthologs'
 import { launchMSA } from '../utils/msa'
 import {
-  COMMON_SPECIES,
+  defaultMaxSpecies,
   fetchOrthologRows,
   fetchProteinForGene,
   resolveGeneId,
 } from '../utils/ncbiOrthologs'
+import { fetchTaxonomyInfo } from '../utils/taxonomyNames'
 
 import type { JBrowsePluginMsaViewModel } from './model'
 import type { OrthologRow } from '../utils/ncbiOrthologs'
 
 // Every network call is mocked and nothing else is. What is under test is the
-// argument shaping either side of those calls -- which taxa get asked for, what
-// becomes the QUERY row, and whether the row earns the Accession that drives the
-// CDD overlay -- so the real COMMON_SPECIES list and the real
-// cleanProteinSequence stay in the picture.
+// argument shaping either side of those calls -- which species get asked for,
+// what becomes the QUERY row, and whether the row earns the Accession that
+// drives the CDD overlay -- so the real cleanProteinSequence stays in the
+// picture.
 vi.mock('../utils/ncbiOrthologs', async importOriginal => ({
   ...(await importOriginal<Record<string, unknown>>()),
   resolveGeneId: vi.fn(),
@@ -24,20 +25,25 @@ vi.mock('../utils/ncbiOrthologs', async importOriginal => ({
   fetchOrthologRows: vi.fn(),
 }))
 vi.mock('../utils/msa', () => ({ launchMSA: vi.fn() }))
+vi.mock('../utils/taxonomyNames', () => ({ fetchTaxonomyInfo: vi.fn() }))
 
 const mockResolveGeneId = vi.mocked(resolveGeneId)
 const mockFetchProtein = vi.mocked(fetchProteinForGene)
 const mockFetchRows = vi.mocked(fetchOrthologRows)
 const mockLaunchMSA = vi.mocked(launchMSA)
+const mockFetchTaxonomy = vi.mocked(fetchTaxonomyInfo)
 
 const HUMAN = 9606
 const GENE_ID = '22861'
 const REPRESENTATIVE = { accession: 'NP_127497.1', sequence: 'MAGGAWGRLACY' }
 
+const setQuerySeqName = vi.fn()
+
 function makeModel(orthologParams: Record<string, unknown>) {
   return {
     orthologParams,
     setProgress: () => {},
+    setQuerySeqName,
   } as unknown as JBrowsePluginMsaViewModel
 }
 
@@ -50,10 +56,15 @@ function params(extra: Record<string, unknown> = {}) {
   }
 }
 
-// What fetchOrthologRows was asked for, which is the only place the taxa
-// default is observable.
-function taxaAskedFor() {
-  return [...mockFetchRows.mock.calls[0]![0].taxa].sort((a, b) => a - b)
+// What fetchOrthologRows was asked for, which is the only place the species
+// defaults are observable.
+function rowRequest() {
+  const { taxa, exclude, limit } = mockFetchRows.mock.calls[0]![0]
+  return {
+    taxa: taxa && [...taxa].sort((a, b) => a - b),
+    exclude,
+    limit,
+  }
 }
 
 // The QUERY row as it went to the aligner, read back out of the FASTA rather
@@ -62,8 +73,18 @@ function queryRowSent() {
   return mockLaunchMSA.mock.calls[0]![0].sequence.split('\n')[1]
 }
 
+// Keyed by the row's own label, which has to be the name the FASTA header
+// carries -- the tree comes back from the aligner naming its leaves that way,
+// and the metadata is paired to a leaf by name.
 function queryMetadata(result: { treeMetadata: string }) {
-  return JSON.parse(result.treeMetadata).QUERY as Record<string, string>
+  return JSON.parse(result.treeMetadata)[queryRowName()] as Record<
+    string,
+    string
+  >
+}
+
+function queryRowName() {
+  return mockLaunchMSA.mock.calls[0]![0].sequence.split('\n')[0]!.slice(1)
 }
 
 beforeEach(() => {
@@ -72,32 +93,99 @@ beforeEach(() => {
   mockFetchProtein.mockResolvedValue(REPRESENTATIVE)
   mockFetchRows.mockResolvedValue([] as OrthologRow[])
   mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' })
+  mockFetchTaxonomy.mockResolvedValue(
+    new Map([[HUMAN, { sciname: 'Homo sapiens', commonName: 'human' }]]),
+  )
 })
 
-describe('taxa', () => {
-  test('omitted asks for every species the dialog offers, less the query', async () => {
+describe('which species become rows', () => {
+  test('omitted taxa asks for no restriction at all, which is every ortholog NCBI has', async () => {
     await doLaunchOrthologs({ self: makeModel(params()) })
-    expect(taxaAskedFor()).toEqual(
-      COMMON_SPECIES.map(s => s.taxId as number)
-        .filter(t => t !== HUMAN)
-        .sort((a, b) => a - b),
-    )
+    expect(rowRequest().taxa).toBeUndefined()
   })
 
-  test('given is taken as written, less the query', async () => {
+  test('given taxa is taken as written', async () => {
     await doLaunchOrthologs({
       self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
     })
-    expect(taxaAskedFor()).toEqual([9615, 10090])
+    expect(rowRequest().taxa).toEqual([9606, 9615, 10090])
+  })
+
+  // Not folded into the taxa list before the call, so that "restrict to these"
+  // and "the query row already covers this one" stay separable -- an unrestricted
+  // launch still has to drop the query species.
+  test('the query species is excluded whether or not taxa was given', async () => {
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(rowRequest().exclude).toBe(HUMAN)
+    vi.clearAllMocks()
+    mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' })
+    mockFetchProtein.mockResolvedValue(REPRESENTATIVE)
+    mockFetchRows.mockResolvedValue([] as OrthologRow[])
+    mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' })
+    await doLaunchOrthologs({
+      self: makeModel(params({ taxa: [HUMAN, 10090] })),
+    })
+    expect(rowRequest().exclude).toBe(HUMAN)
   })
 
   test('an empty list is a request for no rows, not a request for all of them', async () => {
     await doLaunchOrthologs({ self: makeModel(params({ taxa: [] })) })
-    expect(taxaAskedFor()).toEqual([])
+    expect(rowRequest().taxa).toEqual([])
+  })
+})
+
+// The cap is the only thing standing between a launch and a 7 minute EBI job:
+// NCBI publishes 865 orthologs for CFTR and the aligner runs at roughly half a
+// second a row.
+describe('the row cap', () => {
+  test('is passed through when given', async () => {
+    await doLaunchOrthologs({ self: makeModel(params({ maxSpecies: 12 })) })
+    expect(rowRequest().limit).toBe(12)
+  })
+
+  test('omitted leaves the default to fetchOrthologGenes rather than sending Infinity', async () => {
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(rowRequest().limit).toBeUndefined()
+    expect(defaultMaxSpecies).toBeGreaterThan(2)
+  })
+})
+
+// The row's name is load bearing three times over: it is the FASTA header, it
+// is therefore the tree leaf the aligner returns, and it is what
+// `seqPosToVisibleCol` looks up to turn a genome hover into a column. So the
+// model's querySeqName and the header have to be the same string.
+describe('the query row name', () => {
+  test('is the species, marked, rather than a bare QUERY among named rows', async () => {
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(queryRowName()).toBe('human_query')
+    expect(setQuerySeqName).toHaveBeenCalledWith('human_query')
+  })
+
+  test('cannot collide with an ortholog row that sanitizes to the same token', async () => {
+    mockFetchRows.mockResolvedValue([
+      { label: 'human_query', sequence: 'MM' },
+    ] as OrthologRow[])
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(queryRowName()).toBe('human_query_2')
+    expect(setQuerySeqName).toHaveBeenCalledWith('human_query_2')
+  })
+
+  test('falls back rather than throwing when NCBI cannot name the taxon', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockFetchTaxonomy.mockRejectedValue(new Error('429'))
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(queryRowName()).toBe('query_query')
+  })
+
+  test('the metadata that drives the domain overlay is keyed to that same name', async () => {
+    const result = await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(Object.keys(JSON.parse(result.treeMetadata))).toContain(
+      'human_query',
+    )
   })
 })
 
-describe('the QUERY row', () => {
+describe('the query row sequence', () => {
   test('omitted proteinSequence falls back to the representative protein', async () => {
     await doLaunchOrthologs({ self: makeModel(params()) })
     expect(queryRowSent()).toBe(REPRESENTATIVE.sequence)

package/src/MsaViewPanel/doLaunchOrthologs.ts

@@ -1,11 +1,12 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util'
 import { launchMSA } from '../utils/msa'
 import {
-  COMMON_SPECIES,
+  dedupeLabels,
   fetchOrthologRows,
   fetchProteinForGene,
   resolveGeneId,
 } from '../utils/ncbiOrthologs'
+import { fetchTaxonomyInfo } from '../utils/taxonomyNames'
 
 import type { JBrowsePluginMsaViewModel } from './model'
 import type { OrthologRow } from '../utils/ncbiOrthologs'
@@ -30,8 +31,14 @@ export async function doLaunchOrthologs({
 }: {
   self: JBrowsePluginMsaViewModel
 }) {
-  const { taxId, taxa, geneCandidates, msaAlgorithm, proteinSequence } =
-    self.orthologParams!
+  const {
+    taxId,
+    taxa,
+    maxSpecies,
+    geneCandidates,
+    msaAlgorithm,
+    proteinSequence,
+  } = self.orthologParams!
 
   const onProgress = (arg: string) => {
     self.setProgress(arg)
@@ -61,21 +68,40 @@ export async function doLaunchOrthologs({
     )
   }
 
-  // Every species the panel offers, when a launch names none. A spec that wants
-  // a narrower comparison says so; one that just wants "this gene across
-  // species" should not have to enumerate the list the dialog would have
-  // checked for it.
-  const wantedTaxa = taxa ?? COMMON_SPECIES.map(s => s.taxId as number)
-  // the query species is represented by the query row above
-  const wanted = new Set(wantedTaxa.filter(t => t !== taxId))
+  // Every species NCBI has an ortholog for, when a launch names none, capped at
+  // maxSpecies. A launch that wants specific species lists them; one that just
+  // wants "this gene across species" gets NCBI's own order, which leads with the
+  // reference organisms.
   const rows = await fetchOrthologRows({
     geneId: resolved.geneId,
-    taxa: wanted,
+    taxa: taxa ? new Set(taxa) : undefined,
+    // the query species is represented by the query row above
+    exclude: taxId,
+    limit: maxSpecies,
     onProgress,
   })
 
+  // The query row is named for its species like every other row, with a suffix
+  // marking it as the one the genome view is linked to. A bare `QUERY` among
+  // ninety-nine named species reads as a row whose species failed to resolve,
+  // and there is nothing else in the picture saying which row the hover
+  // highlight travels through -- react-msaview has no notion of a query row, it
+  // only looks one up by name.
+  //
+  // Deduped against the ortholog labels rather than assumed unique: the query
+  // taxon is excluded from that set, but a subspecies can sanitize to the same
+  // token, and a collision would silently point the coordinate mapping at
+  // another animal's row.
+  const queryLabel = await queryRowLabel(taxId, rows)
+  self.setQuerySeqName(queryLabel)
+
   const treeMetadata: Record<string, Record<string, string>> = {
-    QUERY: buildQueryMetadata(self, resolved.geneId, cleanedSeq, representative),
+    [queryLabel]: buildQueryMetadata(
+      self,
+      resolved.geneId,
+      cleanedSeq,
+      representative,
+    ),
   }
   for (const row of rows) {
     treeMetadata[row.label] = buildRowMetadata(row)
@@ -84,7 +110,7 @@ export async function doLaunchOrthologs({
   const result = await launchMSA({
     algorithm: msaAlgorithm,
     sequence: [
-      `>QUERY\n${cleanedSeq}`,
+      `>${queryLabel}\n${cleanedSeq}`,
       ...rows.map(r => `>${r.label}\n${r.sequence}`),
     ].join('\n'),
     onProgress,
@@ -96,6 +122,23 @@ export async function doLaunchOrthologs({
   }
 }
 
+/**
+ * `<species>_query`, unique against the ortholog labels. Falls back to the bare
+ * marker when NCBI cannot name the taxon, which is a naming failure and must not
+ * take down the launch.
+ */
+async function queryRowLabel(taxId: number, rows: OrthologRow[]) {
+  let name: string | undefined
+  try {
+    const info = (await fetchTaxonomyInfo([taxId])).get(taxId)
+    name = info?.commonName ?? info?.sciname
+  } catch (e) {
+    console.warn('[msaview-orthologs] taxonomy name lookup failed:', e)
+  }
+  return dedupeLabels([...rows.map(r => r.label), `${name ?? 'query'}_query`])
+    .at(-1)!
+}
+
 /**
  * A failed lookup only costs the query row its domain overlay and, for a launch
  * that supplied no sequence of its own, the alignment — so it is reported by

package/src/MsaViewPanel/model.ts

@@ -56,10 +56,17 @@ export interface OrthologParams {
   taxId: number
   /**
    * taxon ids to include as rows (the query taxon is represented by QUERY).
-   * Omitted means every species the launch dialog offers, which is what a
-   * launch that just wants "this gene across species" wants.
+   * Omitted means every species NCBI has an ortholog for, in its report order,
+   * which is what a launch that just wants "this gene across species" wants.
    */
   taxa?: number[]
+  /**
+   * how many ortholog rows to align, `defaultMaxSpecies` when omitted. The
+   * aligner is what this bounds: EBI runs at roughly half a second per row for
+   * a ~1400aa protein, so a gene with 865 orthologs is a 7 minute job at no
+   * cap.
+   */
+  maxSpecies?: number
   /** candidate gene identifiers off the feature, tried in order */
   geneCandidates: string[]
   msaAlgorithm: MsaAlgorithm