jbrowse-plugin-msaview 2.8.2 → 2.10.0

package/src/MsaViewPanel/doLaunchBlast.ts

@@ -1,8 +1,8 @@
 import { makeId, strip } from '../LaunchMsaView/components/util'
 import { cleanProteinSequence } from '../LaunchMsaView/util'
 import { saveBlastResult } from '../utils/blastCache'
+import { queryEbiBlast } from '../utils/ebiBlast'
 import { launchMSA } from '../utils/msa'
-import { queryBlast, queryBlastFromRid } from '../utils/ncbiBlast'
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames'
 
 import type { JBrowsePluginMsaViewModel } from './model'
@@ -14,39 +14,24 @@ export async function doLaunchBlast({
 }: {
   self: JBrowsePluginMsaViewModel
 }) {
-  const {
-    baseUrl,
-    blastDatabase,
-    blastProgram,
-    msaAlgorithm,
-    proteinSequence,
-    selectedTranscript,
-    rid: existingRid,
-  } = self.blastParams!
+  const { blastDatabase, msaAlgorithm, proteinSequence, selectedTranscript } =
+    self.blastParams!
   const cleanedSeq = cleanProteinSequence(proteinSequence)
 
   const onProgress = (arg: string) => {
     self.setProgress(arg)
   }
 
-  if (existingRid) {
-    // publish it before the first poll so the view can link out to NCBI while
+  const { hits, rid } = await queryEbiBlast({
+    query: cleanedSeq,
+    blastDatabase,
+    onProgress,
+    // publish the job id before the first poll so the view can link out while
     // the job is still running
-    self.setRid(existingRid)
-  }
-
-  const { hits, rid } = existingRid
-    ? await queryBlastFromRid({ rid: existingRid, baseUrl, onProgress })
-    : await queryBlast({
-        query: cleanedSeq,
-        blastDatabase,
-        blastProgram,
-        baseUrl,
-        onProgress,
-        onRid: r => {
-          self.setRid(r)
-        },
-      })
+    onRid: r => {
+      self.setRid(r)
+    },
+  })
 
   self.setProgress('Fetching species taxonomy info...')
   const taxids = hits
@@ -81,7 +66,6 @@ export async function doLaunchBlast({
   await saveBlastResult({
     proteinSequence: cleanedSeq,
     blastDatabase,
-    blastProgram,
     msaAlgorithm,
     msa: result.msa,
     tree: result.tree,

package/src/MsaViewPanel/doLaunchOrthologs.test.ts

@@ -0,0 +1,247 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { doLaunchOrthologs } from './doLaunchOrthologs'
+import { launchMSA } from '../utils/msa'
+import {
+  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 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(),
+  fetchProteinForGene: vi.fn(),
+  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
+}
+
+function params(extra: Record<string, unknown> = {}) {
+  return {
+    taxId: HUMAN,
+    geneCandidates: ['NLRP1'],
+    msaAlgorithm: 'clustalo',
+    ...extra,
+  }
+}
+
+// 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
+// than out of an intermediate, since the FASTA is what the alignment is of.
+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)[queryRowName()] as Record<
+    string,
+    string
+  >
+}
+
+function queryRowName() {
+  return mockLaunchMSA.mock.calls[0]![0].sequence.split('\n')[0]!.slice(1)
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' })
+  mockFetchProtein.mockResolvedValue(REPRESENTATIVE)
+  mockFetchRows.mockResolvedValue([] as OrthologRow[])
+  mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' })
+  mockFetchTaxonomy.mockResolvedValue(
+    new Map([[HUMAN, { sciname: 'Homo sapiens', commonName: 'human' }]]),
+  )
+})
+
+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(rowRequest().taxa).toBeUndefined()
+  })
+
+  test('given taxa is taken as written', async () => {
+    await doLaunchOrthologs({
+      self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
+    })
+    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(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 sequence', () => {
+  test('omitted proteinSequence falls back to the representative protein', async () => {
+    await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(queryRowSent()).toBe(REPRESENTATIVE.sequence)
+  })
+
+  test('a supplied sequence is used, and is cleaned first', async () => {
+    await doLaunchOrthologs({
+      self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
+    })
+    expect(queryRowSent()).toBe('MAGGAWGR')
+  })
+
+  test('throws when neither a sequence nor a representative is available', async () => {
+    mockFetchProtein.mockResolvedValue(undefined)
+    await expect(
+      doLaunchOrthologs({ self: makeModel(params()) }),
+    ).rejects.toThrow(/No query protein/)
+    expect(mockLaunchMSA).not.toHaveBeenCalled()
+  })
+
+  test('a failed representative lookup does not take down a launch that brought its own sequence', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockFetchProtein.mockRejectedValue(new Error('429'))
+    await doLaunchOrthologs({
+      self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
+    })
+    expect(queryRowSent()).toBe(REPRESENTATIVE.sequence)
+  })
+})
+
+// The Accession is what afterCreateAutoruns.autoLoadProteinDomains keys the CDD
+// overlay off, and attaching it to a row that is NOT the protein it names draws
+// every domain box at an offset. So the byte-identity guard is the assertion
+// here, in both directions.
+describe('the Accession that drives the domain overlay', () => {
+  test('is attached when the query row IS the representative protein', async () => {
+    const result = await doLaunchOrthologs({ self: makeModel(params()) })
+    expect(queryMetadata(result)).toMatchObject({
+      'Gene ID': GENE_ID,
+      Accession: REPRESENTATIVE.accession,
+    })
+  })
+
+  test('is withheld from a non-representative isoform', async () => {
+    const result = await doLaunchOrthologs({
+      self: makeModel(params({ proteinSequence: 'MDIFFERENTISOFORM' })),
+    })
+    expect(queryMetadata(result).Accession).toBeUndefined()
+  })
+
+  test('is withheld when the representative lookup failed', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockFetchProtein.mockRejectedValue(new Error('429'))
+    const result = await doLaunchOrthologs({
+      self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
+    })
+    expect(queryMetadata(result).Accession).toBeUndefined()
+  })
+})

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

@@ -28,9 +28,8 @@ import {
 import type { MafRegion, MsaViewInitState } from './types'
 import type {
   BlastDatabase,
-  BlastProgram,
   MsaAlgorithm,
-} from '../LaunchMsaView/components/NCBIBlastQuery/consts'
+} from '../LaunchMsaView/components/BlastQuery/consts'
 import type { Feature } from '@jbrowse/core/util'
 import type { Instance } from '@jbrowse/mobx-state-tree'
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
@@ -46,13 +45,10 @@ export interface IRegion {
 }
 
 export interface BlastParams {
-  baseUrl: string
   blastDatabase: BlastDatabase
   msaAlgorithm: MsaAlgorithm
-  blastProgram: BlastProgram
   selectedTranscript?: Feature
   proteinSequence: string
-  rid?: string
 }
 
 export interface OrthologParams {
@@ -60,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

package/src/utils/blastCache.ts

@@ -2,9 +2,8 @@ import { createDbOpener } from './idb'
 
 import type {
   BlastDatabase,
-  BlastProgram,
   MsaAlgorithm,
-} from '../LaunchMsaView/components/NCBIBlastQuery/consts'
+} from '../LaunchMsaView/components/BlastQuery/consts'
 import type { DBSchema } from 'idb'
 
 const DB_NAME = 'jbrowse-msaview-blast-cache'
@@ -15,7 +14,12 @@ export interface CachedBlastResult {
   id: string
   proteinSequence: string
   blastDatabase: BlastDatabase
-  blastProgram: BlastProgram
+  /**
+   * Only ever set on rows cached by a version that still queried NCBI, where
+   * the choice between blastp and quick-blastp was real. Kept so those rows
+   * still display; never written now.
+   */
+  blastProgram?: string
   msaAlgorithm: MsaAlgorithm
   msa: string
   tree: string
@@ -51,7 +55,6 @@ const getDB = createDbOpener<BlastCacheDB>(
 function createCacheKey(
   proteinSequence: string,
   blastDatabase: BlastDatabase,
-  blastProgram: BlastProgram,
   msaAlgorithm: MsaAlgorithm,
   transcriptId?: string,
 ) {
@@ -59,13 +62,12 @@ function createCacheKey(
   // msaAlgorithm is part of the key because the stored msa/tree are produced by
   // it — without it, re-running the same query under a different algorithm
   // overwrites the earlier result and drops it from the history list
-  return `${blastDatabase}:${blastProgram}:${msaAlgorithm}${idPart}:${proteinSequence}`
+  return `${blastDatabase}:${msaAlgorithm}${idPart}:${proteinSequence}`
 }
 
 export async function saveBlastResult({
   proteinSequence,
   blastDatabase,
-  blastProgram,
   msaAlgorithm,
   msa,
   tree,
@@ -78,7 +80,6 @@ export async function saveBlastResult({
 }: {
   proteinSequence: string
   blastDatabase: BlastDatabase
-  blastProgram: BlastProgram
   msaAlgorithm: MsaAlgorithm
   msa: string
   tree: string
@@ -93,7 +94,6 @@ export async function saveBlastResult({
   const id = createCacheKey(
     proteinSequence,
     blastDatabase,
-    blastProgram,
     msaAlgorithm,
     transcriptId,
   )
@@ -101,7 +101,6 @@ export async function saveBlastResult({
     id,
     proteinSequence,
     blastDatabase,
-    blastProgram,
     msaAlgorithm,
     msa,
     tree,

package/src/utils/ebiBlast.ts

@@ -0,0 +1,114 @@
+import { fetchEbiResult, submitEbiJob, waitForEbiJob } from './ebiJobDispatcher'
+
+import type { BlastHit } from './types'
+import type { BlastDatabase } from '../LaunchMsaView/components/BlastQuery/consts'
+
+const TOOL = 'ncbiblast'
+
+/**
+ * The subset of EBI's ncbiblast JSON result this plugin reads. The service
+ * returns a great deal more per hit (urls, bit scores, e-values, the match
+ * string); only what the MSA rows are built from is typed here.
+ */
+interface EbiBlastJson {
+  hits?: {
+    hit_acc?: string
+    hit_id?: string
+    hit_desc?: string
+    /** the UniProt fields are absent on hits from non-UniProt databases */
+    hit_os?: string
+    hit_uni_de?: string
+    hit_uni_os?: string
+    /** NCBI taxon id, delivered as a string */
+    hit_uni_ox?: string
+    hit_hsps?: { hsp_hseq?: string }[]
+  }[]
+}
+
+/**
+ * Map EBI's hit shape onto the normalized one. Exported for testing against a
+ * captured response — the field names are the whole risk here, and nothing else
+ * in CI would notice if EBI renamed one.
+ */
+export function normalizeEbiBlastHits(result: EbiBlastJson): BlastHit[] {
+  return (result.hits ?? []).map(hit => {
+    const taxid = Number.parseInt(hit.hit_uni_ox ?? '', 10)
+    return {
+      description: [
+        {
+          accession: hit.hit_acc ?? 'unknown',
+          id: hit.hit_id ?? hit.hit_acc ?? 'unknown',
+          sciname: hit.hit_uni_os ?? hit.hit_os ?? 'unknown',
+          taxid: Number.isNaN(taxid) ? undefined : taxid,
+          // hit_uni_de is the bare protein name; hit_desc repeats it with the
+          // OS=/OX=/GN= suffix that makeId already covers with real columns
+          title: hit.hit_uni_de ?? hit.hit_desc,
+        },
+      ],
+      hsps: (hit.hit_hsps ?? []).flatMap(hsp =>
+        hsp.hsp_hseq ? [{ hseq: hsp.hsp_hseq }] : [],
+      ),
+    }
+  })
+}
+
+/**
+ * Human-facing link to a job, shown while it runs and on error — so it has to
+ * be EBI's own results UI, not the REST result endpoint, which does not exist
+ * yet at the moment the link is on screen.
+ */
+export function ebiBlastResultUrl(jobId: string) {
+  return `https://www.ebi.ac.uk/jdispatcher/sss/${TOOL}/summary?jobId=${jobId}`
+}
+
+export async function queryEbiBlastFromJobId({
+  jobId,
+  onProgress,
+}: {
+  jobId: string
+  onProgress: (arg: string) => void
+}) {
+  onProgress(`Checking BLAST status for job: ${jobId}...`)
+  await waitForEbiJob({
+    tool: TOOL,
+    jobId,
+    onCountdown: s => {
+      onProgress(`Re-checking BLAST status in... ${s}`)
+    },
+  })
+
+  const hits = normalizeEbiBlastHits(
+    JSON.parse(
+      await fetchEbiResult({ tool: TOOL, jobId, type: 'json' }),
+    ) as EbiBlastJson,
+  )
+  if (hits.length === 0) {
+    throw new Error('No hits found')
+  }
+  return { rid: jobId, hits }
+}
+
+export async function queryEbiBlast({
+  query,
+  blastDatabase,
+  onProgress,
+  onRid,
+}: {
+  query: string
+  blastDatabase: BlastDatabase
+  onProgress: (arg: string) => void
+  onRid: (arg: string) => void
+}) {
+  onProgress('Submitting to EBI BLAST...')
+  const jobId = await submitEbiJob({
+    tool: TOOL,
+    params: {
+      program: 'blastp',
+      stype: 'protein',
+      database: blastDatabase,
+      sequence: query,
+    },
+  })
+  onRid(jobId)
+  return queryEbiBlastFromJobId({ jobId, onProgress })
+}