jbrowse-plugin-msaview 2.8.2 → 2.10.0

package/src/utils/ebiJobDispatcher.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, test, vi } from 'vitest'
+
+import { waitForEbiJob } from './ebiJobDispatcher'
+
+// A long alignment is polled every ten seconds for minutes, so the chance of one
+// failed status check somewhere in that window is not small -- and the job is
+// running at EBI regardless of what happens to the poller's connection.
+describe('waitForEbiJob', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  const statuses = (seq: (string | Error)[]) => {
+    let i = 0
+    vi.stubGlobal('fetch', () => {
+      const next = seq[Math.min(i++, seq.length - 1)]!
+      return next instanceof Error
+        ? Promise.reject(next)
+        : Promise.resolve({
+            ok: true,
+            status: 200,
+            text: () => Promise.resolve(next),
+          })
+    })
+  }
+  const wait = () =>
+    waitForEbiJob({
+      tool: 'clustalo',
+      jobId: 'job1',
+      intervalSeconds: 0,
+      onCountdown: () => {},
+    })
+
+  test('a transient failure mid-poll does not abandon a job that then finishes', async () => {
+    statuses(['RUNNING', new TypeError('Failed to fetch'), 'FINISHED'])
+    await expect(wait()).resolves.toBeUndefined()
+  })
+
+  test('failures that do not persist never accumulate to the limit', async () => {
+    const blip = new TypeError('Failed to fetch')
+    statuses([blip, 'RUNNING', blip, 'RUNNING', blip, 'RUNNING', blip, 'FINISHED'])
+    await expect(wait()).resolves.toBeUndefined()
+  })
+
+  test('an endpoint that has genuinely gone away is not polled forever', async () => {
+    statuses([new TypeError('Failed to fetch')])
+    await expect(wait()).rejects.toThrow(/Could not reach EBI/)
+  })
+
+  test('a job EBI reports as failed still ends the poll immediately', async () => {
+    statuses(['ERROR'])
+    await expect(wait()).rejects.toThrow(/returned status ERROR/)
+  })
+})

package/src/utils/ebiJobDispatcher.ts

@@ -0,0 +1,120 @@
+import { textfetch } from './fetch'
+import { pollLoop } from './poll'
+import { readLocalStorage } from './useLocalStorage'
+
+/**
+ * EBI's Job Dispatcher REST services (clustalo, muscle, ncbiblast, ...) all
+ * speak the same run/status/result protocol, so the transport lives here and
+ * each tool only supplies its own parameters and result types.
+ *
+ * Unlike NCBI's Blast.cgi these endpoints send `Access-Control-Allow-Origin: *`,
+ * which is why the BLAST backend moved here — see docs/blast.md.
+ */
+export const EBI_BASE = 'https://www.ebi.ac.uk/Tools/services/rest'
+
+/**
+ * EBI asks for a contact address on every submission so they can reach whoever
+ * is generating the load. A deployment that sends real volume should point this
+ * at its own maintainer via the BLAST settings dialog — otherwise every
+ * msaview job in the world is attributed to one person.
+ */
+export const EBI_EMAIL_STORAGE_KEY = 'msa-ebiContactEmail'
+export const DEFAULT_EBI_EMAIL = 'colin.diesh@gmail.com'
+
+export function getEbiEmail() {
+  const configured = readLocalStorage(
+    EBI_EMAIL_STORAGE_KEY,
+    DEFAULT_EBI_EMAIL,
+  ).trim()
+  return configured || DEFAULT_EBI_EMAIL
+}
+
+/** Statuses that mean the job is over and produced no result. */
+const FAILED_STATUSES = new Set(['ERROR', 'FAILURE', 'NOT_FOUND'])
+
+export async function submitEbiJob({
+  tool,
+  params,
+}: {
+  tool: string
+  params: Record<string, string>
+}) {
+  const jobId = await textfetch(`${EBI_BASE}/${tool}/run`, {
+    method: 'POST',
+    body: new URLSearchParams({ email: getEbiEmail(), ...params }),
+  })
+  return jobId.trim()
+}
+
+/**
+ * A status check that could not reach EBI at all says nothing about the job, so
+ * it is not a reason to abandon one. A job the server has accepted keeps running
+ * whatever happens to the poller's connection, and the poll is the long part: an
+ * alignment of a hundred sequences runs for minutes and is checked every ten
+ * seconds, so a single blip anywhere in that window used to throw away a job
+ * that went on to finish.
+ *
+ * Consecutive failures still end it, because an endpoint that has genuinely gone
+ * away must not be polled forever.
+ */
+const MAX_CONSECUTIVE_STATUS_FAILURES = 5
+
+export async function waitForEbiJob({
+  tool,
+  jobId,
+  intervalSeconds = 10,
+  onCountdown,
+}: {
+  tool: string
+  jobId: string
+  intervalSeconds?: number
+  onCountdown: (secondsRemaining: number) => void
+}) {
+  let consecutiveFailures = 0
+  await pollLoop({
+    intervalSeconds,
+    onCountdown,
+    check: async () => {
+      let status: string
+      try {
+        status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim()
+      } catch (e) {
+        consecutiveFailures += 1
+        if (consecutiveFailures >= MAX_CONSECUTIVE_STATUS_FAILURES) {
+          throw new Error(
+            `Could not reach EBI to check ${tool} job ${jobId} after ${consecutiveFailures} tries`,
+            { cause: e },
+          )
+        }
+        console.warn(
+          `[msaview] EBI status check ${consecutiveFailures} failed, retrying:`,
+          e,
+        )
+        return false
+      }
+      consecutiveFailures = 0
+      // exact match, not includes(): a job whose status is ERROR must not be
+      // able to poll forever waiting for a FINISHED that will never arrive
+      if (status === 'FINISHED') {
+        return true
+      }
+      if (FAILED_STATUSES.has(status)) {
+        throw new Error(`EBI ${tool} job ${jobId} returned status ${status}`)
+      }
+      // RUNNING, QUEUED, PENDING and anything else EBI adds later
+      return false
+    },
+  })
+}
+
+export async function fetchEbiResult({
+  tool,
+  jobId,
+  type,
+}: {
+  tool: string
+  jobId: string
+  type: string
+}) {
+  return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`)
+}

package/src/utils/eutils.ts

@@ -14,3 +14,22 @@ export function efetchUrl(params: Record<string, string>) {
   })
   return `${EUTILS}/efetch.fcgi?${search.toString()}`
 }
+
+/**
+ * The same request as a POST body. An `id` list of a few hundred accessions
+ * exceeds what a URL carries — 865 of them is ~13KB — and NCBI documents POST
+ * as the route above about 200 ids. eutils sends `ACAO: *` on both verbs.
+ */
+export function efetchPost(params: Record<string, string>) {
+  return [
+    `${EUTILS}/efetch.fcgi`,
+    {
+      method: 'POST',
+      body: new URLSearchParams({
+        ...params,
+        tool: NCBI_TOOL,
+        email: NCBI_EMAIL,
+      }),
+    },
+  ] as const
+}

package/src/utils/fetch.ts

@@ -1,5 +1,30 @@
+function hostOf(url: string) {
+  try {
+    return new URL(url).host
+  } catch {
+    // a relative url, e.g. a same-origin proxy path
+    return url
+  }
+}
+
 export async function handleFetch(url: string, args?: RequestInit) {
-  const response = await fetch(url, args)
+  let response: Response
+  try {
+    response = await fetch(url, args)
+  } catch (e) {
+    // fetch rejects with a bare "TypeError: Failed to fetch" for every network
+    // level failure, including a cross-origin response the browser refused to
+    // hand over. That is not a hypothetical: NCBI's Blast.cgi stopped sending
+    // Access-Control-Allow-Origin to third-party origins, and the raw TypeError
+    // told users nothing at all about why. See docs/blast.md.
+    if (e instanceof TypeError) {
+      throw new Error(
+        `Could not reach ${hostOf(url)} — the request failed at the network level. This is usually a CORS restriction (the server refused to let this site read the response), an offline connection, or a blocked request.`,
+        { cause: e },
+      )
+    }
+    throw e
+  }
 
   if (!response.ok) {
     throw new Error(

package/src/utils/msa.ts

@@ -1,10 +1,6 @@
-import { textfetch } from './fetch'
-import { pollLoop } from './poll'
+import { fetchEbiResult, submitEbiJob, waitForEbiJob } from './ebiJobDispatcher'
 
-import type { MsaAlgorithm } from '../LaunchMsaView/components/NCBIBlastQuery/consts'
-
-const base = `https://www.ebi.ac.uk/Tools/services/rest`
-const email = 'colin.diesh@gmail.com'
+import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts'
 
 const algorithms: Record<
   MsaAlgorithm,
@@ -15,54 +11,27 @@ const algorithms: Record<
   }
 > = {
   clustalo: {
-    params: { email },
+    params: {},
     msaResult: 'aln-clustal_num',
     treeResult: 'phylotree',
   },
   muscle: {
-    params: { email, format: 'clw', tree: 'tree1' },
+    params: { format: 'clw', tree: 'tree1' },
     msaResult: 'fa',
     treeResult: 'phylotree',
   },
   kalign: {
-    params: { email, stype: 'protein' },
+    params: { stype: 'protein' },
     msaResult: 'fa',
     treeResult: 'phylotree',
   },
   mafft: {
-    params: { email, stype: 'protein' },
+    params: { stype: 'protein' },
     msaResult: 'fa',
     treeResult: 'phylotree',
   },
 }
 
-async function wait({
-  onProgress,
-  jobId,
-  algorithm,
-}: {
-  jobId: string
-  algorithm: MsaAlgorithm
-  onProgress: (arg: string) => void
-}) {
-  await pollLoop({
-    intervalSeconds: 10,
-    onCountdown: s => {
-      onProgress(`Re-checking MSA status in... ${s}`)
-    },
-    check: async () => {
-      const result = await textfetch(`${base}/${algorithm}/status/${jobId}`)
-      if (result.includes('FINISHED')) {
-        return true
-      }
-      if (result.includes('FAILURE')) {
-        throw new Error(`Failed to run: jobId ${jobId}`)
-      }
-      return false
-    },
-  })
-}
-
 export async function launchMSA({
   algorithm,
   sequence,
@@ -76,17 +45,27 @@ export async function launchMSA({
 
   onProgress(`Launching ${algorithm} MSA...`)
 
-  const jobId = await textfetch(`${base}/${algorithm}/run`, {
-    method: 'POST',
-    body: new URLSearchParams({ ...config.params, sequence }),
+  const jobId = await submitEbiJob({
+    tool: algorithm,
+    params: { ...config.params, sequence },
+  })
+  await waitForEbiJob({
+    tool: algorithm,
+    jobId,
+    onCountdown: s => {
+      onProgress(`Re-checking MSA status in... ${s}`)
+    },
   })
-  await wait({ jobId, algorithm, onProgress })
   return {
-    msa: await textfetch(
-      `${base}/${algorithm}/result/${jobId}/${config.msaResult}`,
-    ),
-    tree: await textfetch(
-      `${base}/${algorithm}/result/${jobId}/${config.treeResult}`,
-    ),
+    msa: await fetchEbiResult({
+      tool: algorithm,
+      jobId,
+      type: config.msaResult,
+    }),
+    tree: await fetchEbiResult({
+      tool: algorithm,
+      jobId,
+      type: config.treeResult,
+    }),
   }
 }

package/src/utils/ncbiOrthologs.test.ts

@@ -1,6 +1,11 @@
-import { describe, expect, test } from 'vitest'
+import { afterEach, describe, expect, test, vi } from 'vitest'
 
-import { dedupeLabels, parseFasta } from './ncbiOrthologs'
+import {
+  dedupeLabels,
+  fetchOrthologGenes,
+  fetchRepresentativeProteins,
+  parseFasta,
+} from './ncbiOrthologs'
 
 describe('dedupeLabels', () => {
   test('sanitizes to single tokens', () => {
@@ -54,3 +59,92 @@ describe('parseFasta', () => {
     )
   })
 })
+
+// The two ceilings that make a widened species set silently return fewer rows.
+// Both are shaped like a successful response, so only a test that counts what
+// came back sees them.
+describe('the NCBI request ceilings', () => {
+  const stubFetch = (handler: (url: string) => unknown) => {
+    const seen: string[] = []
+    vi.stubGlobal('fetch', (url: string) => {
+      seen.push(url)
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(handler(url)),
+        text: () => Promise.resolve(JSON.stringify(handler(url))),
+      })
+    })
+    return seen
+  }
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  const orthologReport = (n: number) => ({
+    total_count: n,
+    reports: Array.from({ length: n }, (_, i) => ({
+      gene: {
+        gene_id: String(1000 + i),
+        tax_id: String(2000 + i),
+        taxname: `Species ${i}`,
+      },
+    })),
+  })
+
+  test('fetchOrthologGenes takes a prefix of NCBI report order, not a filtered intersection', async () => {
+    stubFetch(() => orthologReport(165))
+    const genes = await fetchOrthologGenes('22861', { limit: 10 })
+    expect(genes.length).toBe(10)
+    // the report's own order, which leads with the reference organisms
+    expect(genes.map(g => g.geneId)).toEqual(
+      Array.from({ length: 10 }, (_, i) => String(1000 + i)),
+    )
+  })
+
+  test('fetchOrthologGenes drops the query taxon without spending a row on it', async () => {
+    stubFetch(() => orthologReport(165))
+    const genes = await fetchOrthologGenes('22861', { exclude: 2000, limit: 3 })
+    expect(genes.map(g => g.taxId)).toEqual([2001, 2002, 2003])
+  })
+
+  test('fetchRepresentativeProteins chunks the gene ids below the URI length NCBI 414s at', async () => {
+    // 865 CFTR ortholog gene ids join to 8609 characters, which NCBI answers
+    // with HTTP 414 rather than a short result
+    const ids = Array.from({ length: 400 }, (_, i) => String(100000 + i))
+    const seen = stubFetch(url => ({
+      reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '').split(',').map(id => ({
+        product: {
+          gene_id: id,
+          transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+        },
+      })),
+    }))
+    const byGene = await fetchRepresentativeProteins(ids)
+    expect(byGene.size).toBe(400)
+    expect(seen.length).toBeGreaterThan(1)
+    expect(Math.max(...seen.map(u => u.length))).toBeLessThan(8000)
+  })
+
+  test('fetchRepresentativeProteins asks for a page big enough to hold its chunk', async () => {
+    // the endpoint paginates at 20 by default and hides the rest behind
+    // next_page_token, so a caller reading only `reports` loses everything past
+    // the first page and reports no protein for those genes
+    const ids = Array.from({ length: 50 }, (_, i) => String(100000 + i))
+    const seen = stubFetch(url => ({
+      reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '')
+        .split(',')
+        .slice(0, Number(/page_size=(\d+)/.exec(url)?.[1] ?? 20))
+        .map(id => ({
+          product: {
+            gene_id: id,
+            transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+          },
+        })),
+    }))
+    const byGene = await fetchRepresentativeProteins(ids)
+    expect(byGene.size).toBe(50)
+    expect(seen.every(u => /page_size=\d+/.test(u))).toBe(true)
+  })
+})

package/src/utils/ncbiOrthologs.ts

@@ -15,7 +15,7 @@
 // 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 { NCBI_EMAIL, NCBI_TOOL, efetchPost } from './eutils'
 import { jsonfetch, textfetch } from './fetch'
 
 // v2, not v2alpha: the alpha path still answers /orthologs but 404s
@@ -24,64 +24,34 @@ import { jsonfetch, textfetch } from './fetch'
 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.
+// NCBI's ortholog report IS the species panel. There is no list here to keep in
+// step with what NCBI knows, and the panel widens by itself as NCBI annotates
+// more genomes.
 //
-// The index order is the order the sequences are SUBMITTED in
-// (`COMMON_TAX_RANK` below sorts `fetchOrthologGenes`' return), not the order the
-// rows are drawn in: the view lays rows out by the guide tree the aligner returns,
-// so a run on this list comes out grouped by relatedness rather than by this
-// list's own sequence. Reordering here changes what Clustal is handed, not the
-// picture.
+// It used to be a hand-written 23-species list intersected with the report, and
+// the intersection is what made the alignment thin: NCBI publishes 165 orthologs
+// for human NLRP1 and 865 for CFTR, so the list kept 12 of the first and 19 of
+// the second. It also carried four species -- fruitfly, yeast, C. elegans and
+// arabidopsis -- that the endpoint has never once returned for a human gene:
+// checked against NLRP1, TP53, ACTB, BRCA1, PIK3CA, APOE and NOTCH1, whose fly
+// ortholog is famous and still absent. NCBI's ortholog sets are vertebrate
+// scoped.
 //
-// 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.
+// The report's OWN order is the ladder the list was hand-built to approximate,
+// and it is per gene. CFTR opens human, mouse, rat, zebrafish, pig, sheep,
+// rabbit, chicken, cattle, ferret, dog, rhesus; NLRP1, which has no ortholog
+// outside placental mammals, opens human, mouse, rhesus, shrew mouse, chimp,
+// dog, cattle, horse. So `limit` takes a prefix and never needs a rank table.
 //
-// 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 rows are SUBMITTED in that order, not drawn in it -- the view lays rows out
+// by the guide tree the aligner returns.
 //
-// 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 },
-] as const
-
-export const COMMON_TAX_RANK = new Map(
-  COMMON_SPECIES.map((s, i) => [s.taxId as number, i]),
-)
+// What limits the row count is the aligner, and it is linear in rows at roughly
+// half a second each for a ~1400aa protein: 165 NLRP1 orthologs align at EBI in
+// 88s, 865 CFTR orthologs in 407s. `defaultMaxSpecies` keeps a default run under
+// a minute; EBI's own ceiling is 4000 sequences and 4MB, which even CFTR's full
+// set (1.3MB) sits inside.
+export const defaultMaxSpecies = 100
 
 export interface OrthologRow {
   taxId: number
@@ -148,8 +118,21 @@ interface OrthologReport {
   }[]
 }
 
-/** One ortholog gene per species, restricted to the requested taxa. */
-export async function fetchOrthologGenes(geneId: string, taxa: Set<number>) {
+/**
+ * One ortholog gene per species, in NCBI's report order, capped at `limit`.
+ *
+ * `taxa` narrows the set when a caller wants specific species; omitted, every
+ * species NCBI has an ortholog for is a candidate. `exclude` drops the query
+ * taxon, which the QUERY row already represents.
+ */
+export async function fetchOrthologGenes(
+  geneId: string,
+  {
+    taxa,
+    exclude,
+    limit = defaultMaxSpecies,
+  }: { taxa?: Set<number>; exclude?: number; limit?: number } = {},
+) {
   const json = await jsonfetch<OrthologReport>(
     ncbiUrl(
       `${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`,
@@ -166,7 +149,12 @@ export async function fetchOrthologGenes(geneId: string, taxa: Set<number>) {
   >()
   for (const { gene } of json.reports ?? []) {
     const taxId = Number(gene?.tax_id)
-    if (gene?.gene_id && taxa.has(taxId) && !byTaxon.has(taxId)) {
+    if (
+      gene?.gene_id &&
+      taxId !== exclude &&
+      (taxa?.has(taxId) ?? true) &&
+      !byTaxon.has(taxId)
+    ) {
       byTaxon.set(taxId, {
         taxId,
         geneId: gene.gene_id,
@@ -174,12 +162,11 @@ export async function fetchOrthologGenes(geneId: string, taxa: Set<number>) {
         commonName: gene.common_name,
       })
     }
+    if (byTaxon.size >= limit) {
+      break
+    }
   }
-  return [...byTaxon.values()].sort(
-    (a, b) =>
-      (COMMON_TAX_RANK.get(a.taxId) ?? Infinity) -
-      (COMMON_TAX_RANK.get(b.taxId) ?? Infinity),
-  )
+  return [...byTaxon.values()]
 }
 
 interface ProductReport {
@@ -194,6 +181,21 @@ interface ProductReport {
   }[]
 }
 
+// Two ceilings sit between a gene id list and its product report, and both fail
+// by returning less rather than by erroring, so a caller that ignores them just
+// draws a thinner alignment.
+//
+// The ids go in the URL PATH, and NCBI answers HTTP 414 above roughly 8KB of
+// them -- CFTR's 865 orthologs join to 8609 characters and 414 on the nose.
+// `PRODUCT_REPORT_CHUNK` keeps a request well inside that.
+//
+// Then the endpoint paginates at 20 with the count in `total_count` and the rest
+// behind `next_page_token`, which is invisible to a caller reading `reports`.
+// `page_size` covers a chunk in one request. The old 23-species panel never
+// reached this: the query taxon is excluded and NCBI has no ortholog for the
+// four invertebrate entries, so its ceiling was 19.
+const PRODUCT_REPORT_CHUNK = 150
+
 /**
  * geneId -> representative protein accession: MANE Select where flagged, else
  * the longest isoform. A stable, comparable choice across species — picking
@@ -201,9 +203,12 @@ interface ProductReport {
  */
 export async function fetchRepresentativeProteins(geneIds: string[]) {
   const byGene = new Map<string, string>()
-  if (geneIds.length > 0) {
+  for (let i = 0; i < geneIds.length; i += PRODUCT_REPORT_CHUNK) {
+    const chunk = geneIds.slice(i, i + PRODUCT_REPORT_CHUNK)
     const json = await jsonfetch<ProductReport>(
-      ncbiUrl(`${DATASETS}/gene/id/${geneIds.join(',')}/product_report`),
+      ncbiUrl(
+        `${DATASETS}/gene/id/${chunk.join(',')}/product_report?page_size=${chunk.length}`,
+      ),
     )
     for (const { product } of json.reports ?? []) {
       const candidates = (product?.transcripts ?? [])
@@ -297,17 +302,21 @@ export async function fetchProteinForGene(geneId: string) {
 export async function fetchOrthologRows({
   geneId,
   taxa,
+  exclude,
+  limit,
   onProgress,
 }: {
   geneId: string
-  taxa: Set<number>
+  taxa?: Set<number>
+  exclude?: number
+  limit?: number
   onProgress: (arg: string) => void
 }): Promise<OrthologRow[]> {
   onProgress('Finding orthologs across species...')
-  const genes = await fetchOrthologGenes(geneId, taxa)
+  const genes = await fetchOrthologGenes(geneId, { taxa, exclude, limit })
   if (genes.length < 2) {
     throw new Error(
-      `Only ${genes.length} ortholog(s) found among the selected species — not enough to align`,
+      `Only ${genes.length} ortholog(s) found for this gene — not enough to align`,
     )
   }
 
@@ -326,9 +335,12 @@ export async function fetchOrthologRows({
   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`,
-      ),
+      ...efetchPost({
+        db: 'protein',
+        id: accessions.join(','),
+        rettype: 'fasta',
+        retmode: 'text',
+      }),
     ),
   )