jbrowse-plugin-msaview 3.4.0 → 3.4.1

package/dist/utils/blastCache.js

@@ -2,6 +2,12 @@ import { createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-blast-cache';
 const STORE_NAME = 'blast-results';
 const DB_VERSION = 2;
+/**
+ * How many results the history keeps. Every row holds a whole alignment and its
+ * tree — megabytes each — so an unbounded store grows until the browser starts
+ * refusing writes to it, and the user never sees why.
+ */
+const MAX_CACHED_RESULTS = 50;
 const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
     if (oldVersion < 2 && db.objectStoreNames.contains(STORE_NAME)) {
         db.deleteObjectStore(STORE_NAME);
@@ -48,8 +54,34 @@ export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgor
         geneName,
     };
     await db.put(STORE_NAME, entry);
+    await evictOldest(db);
     return entry;
 }
+/**
+ * Drop the oldest rows until the store is back at MAX_CACHED_RESULTS.
+ *
+ * `count` first so the common save reads no values at all: without a timestamp
+ * index the oldest have to be found by loading every row, and each one is an
+ * entire alignment. Failing to evict must not fail the save — the result is
+ * already in hand and losing it to a housekeeping error would be the worse
+ * outcome.
+ */
+async function evictOldest(db) {
+    try {
+        if ((await db.count(STORE_NAME)) <= MAX_CACHED_RESULTS) {
+            return;
+        }
+        const all = await db.getAll(STORE_NAME);
+        const doomed = all
+            .toSorted((a, b) => a.timestamp - b.timestamp)
+            .slice(0, all.length - MAX_CACHED_RESULTS);
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        await Promise.all([...doomed.map(e => tx.store.delete(e.id)), tx.done]);
+    }
+    catch (e) {
+        console.warn('Failed to evict old BLAST cache entries:', e);
+    }
+}
 export async function getAllCachedResults() {
     const db = await getDB();
     const results = await db.getAll(STORE_NAME);

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

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

package/dist/utils/blastCache.test.js

@@ -0,0 +1,72 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { getAllCachedResults, saveBlastResult } from './blastCache';
+// An in-memory stand-in for the one object store this module opens. Only the
+// idb calls blastCache makes are implemented; anything else would be untested
+// scaffolding.
+const { rows } = vi.hoisted(() => ({
+    rows: new Map(),
+}));
+vi.mock('./idb', () => ({
+    createDbOpener: () => () => Promise.resolve({
+        put: (_store, value) => {
+            rows.set(value.id, value);
+            return Promise.resolve(value.id);
+        },
+        count: () => Promise.resolve(rows.size),
+        getAll: () => Promise.resolve([...rows.values()]),
+        transaction: () => ({
+            store: {
+                delete: (id) => {
+                    rows.delete(id);
+                    return Promise.resolve();
+                },
+            },
+            done: Promise.resolve(),
+        }),
+    }),
+}));
+function save(n) {
+    return saveBlastResult({
+        proteinSequence: `SEQ${n}`,
+        blastDatabase: 'uniprotkb_swissprot',
+        msaAlgorithm: 'clustalo',
+        msa: '>a\nMK',
+        tree: '(a);',
+        treeMetadata: '{}',
+        rid: `job-${n}`,
+    });
+}
+beforeEach(() => {
+    rows.clear();
+    // strictly increasing, so "oldest" is unambiguous -- 55 saves in one
+    // millisecond would otherwise all carry the same timestamp
+    let clock = 1;
+    vi.spyOn(Date, 'now').mockImplementation(() => clock++);
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+test('a store at the cap loses nothing', async () => {
+    for (let i = 0; i < 50; i++) {
+        await save(i);
+    }
+    expect(rows.size).toBe(50);
+});
+// Every row holds a whole alignment and its tree, so an unbounded store grows
+// until the browser refuses writes to it and the user never learns why.
+test('going over the cap drops the oldest results and keeps the newest 50', async () => {
+    for (let i = 0; i < 55; i++) {
+        await save(i);
+    }
+    expect(rows.size).toBe(50);
+    const rids = (await getAllCachedResults()).map((r) => r.rid);
+    expect(rids.at(0)).toBe('job-54');
+    expect(rids.at(-1)).toBe('job-5');
+});
+test('re-saving the same query overwrites its row rather than growing the store', async () => {
+    for (let i = 0; i < 50; i++) {
+        await save(i);
+    }
+    await save(0);
+    expect(rows.size).toBe(50);
+});

package/dist/utils/ebiBlast.d.ts

@@ -33,18 +33,20 @@ export declare function normalizeEbiBlastHits(result: EbiBlastJson): BlastHit[];
  * yet at the moment the link is on screen.
  */
 export declare function ebiBlastResultUrl(jobId: string): string;
-export declare function queryEbiBlastFromJobId({ jobId, onProgress, }: {
+export declare function queryEbiBlastFromJobId({ jobId, onProgress, signal, }: {
     jobId: string;
     onProgress: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     rid: string;
     hits: BlastHit[];
 }>;
-export declare function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }: {
+export declare function queryEbiBlast({ query, blastDatabase, onProgress, onRid, signal, }: {
     query: string;
     blastDatabase: BlastDatabase;
     onProgress: (arg: string) => void;
     onRid: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     rid: string;
     hits: BlastHit[];

package/dist/utils/ebiBlast.js

@@ -32,22 +32,23 @@ export function normalizeEbiBlastHits(result) {
 export function ebiBlastResultUrl(jobId) {
     return `https://www.ebi.ac.uk/jdispatcher/sss/${TOOL}/summary?jobId=${jobId}`;
 }
-export async function queryEbiBlastFromJobId({ jobId, onProgress, }) {
+export async function queryEbiBlastFromJobId({ jobId, onProgress, signal, }) {
     onProgress(`Checking BLAST status for job: ${jobId}...`);
     await waitForEbiJob({
         tool: TOOL,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking BLAST status in... ${s}`);
         },
     });
-    const hits = normalizeEbiBlastHits(JSON.parse(await fetchEbiResult({ tool: TOOL, jobId, type: 'json' })));
+    const hits = normalizeEbiBlastHits(JSON.parse(await fetchEbiResult({ tool: TOOL, jobId, type: 'json', signal })));
     if (hits.length === 0) {
         throw new Error('No hits found');
     }
     return { rid: jobId, hits };
 }
-export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }) {
+export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, signal, }) {
     onProgress('Submitting to EBI BLAST...');
     const jobId = await submitEbiJob({
         tool: TOOL,
@@ -57,7 +58,8 @@ export async function queryEbiBlast({ query, blastDatabase, onProgress, onRid, }
             database: blastDatabase,
             sequence: query,
         },
+        signal,
     });
     onRid(jobId);
-    return queryEbiBlastFromJobId({ jobId, onProgress });
+    return queryEbiBlastFromJobId({ jobId, onProgress, signal });
 }

package/dist/utils/ebiJobDispatcher.d.ts

@@ -16,18 +16,21 @@ export declare const EBI_BASE = "https://www.ebi.ac.uk/Tools/services/rest";
 export declare const EBI_EMAIL_STORAGE_KEY = "msa-ebiContactEmail";
 export declare const DEFAULT_EBI_EMAIL = "colin.diesh@gmail.com";
 export declare function getEbiEmail(): string;
-export declare function submitEbiJob({ tool, params, }: {
+export declare function submitEbiJob({ tool, params, signal, }: {
     tool: string;
     params: Record<string, string>;
+    signal?: AbortSignal;
 }): Promise<string>;
-export declare function waitForEbiJob({ tool, jobId, intervalSeconds, onCountdown, }: {
+export declare function waitForEbiJob({ tool, jobId, intervalSeconds, onCountdown, signal, }: {
     tool: string;
     jobId: string;
     intervalSeconds?: number;
     onCountdown: (secondsRemaining: number) => void;
+    signal?: AbortSignal;
 }): Promise<void>;
-export declare function fetchEbiResult({ tool, jobId, type, }: {
+export declare function fetchEbiResult({ tool, jobId, type, signal, }: {
     tool: string;
     jobId: string;
     type: string;
+    signal?: AbortSignal;
 }): Promise<string>;

package/dist/utils/ebiJobDispatcher.js

@@ -1,4 +1,4 @@
-import { textfetch } from './fetch';
+import { isAbortError, textfetch } from './fetch';
 import { pollLoop } from './poll';
 import { readLocalStorage } from './useLocalStorage';
 /**
@@ -24,10 +24,11 @@ export function getEbiEmail() {
 }
 /** 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, }) {
+export async function submitEbiJob({ tool, params, signal, }) {
     const jobId = await textfetch(`${EBI_BASE}/${tool}/run`, {
         method: 'POST',
         body: new URLSearchParams({ email: getEbiEmail(), ...params }),
+        signal,
     });
     return jobId.trim();
 }
@@ -43,17 +44,23 @@ export async function submitEbiJob({ tool, params, }) {
  * away must not be polled forever.
  */
 const MAX_CONSECUTIVE_STATUS_FAILURES = 5;
-export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, }) {
+export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, signal, }) {
     let consecutiveFailures = 0;
     await pollLoop({
         intervalSeconds,
         onCountdown,
+        signal,
         check: async () => {
             let status;
             try {
-                status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim();
+                status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`, { signal })).trim();
             }
             catch (e) {
+                // a cancelled request is the caller giving up, not EBI being
+                // unreachable, so it must end the poll rather than be retried
+                if (isAbortError(e)) {
+                    throw 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 });
@@ -75,6 +82,6 @@ export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCount
         },
     });
 }
-export async function fetchEbiResult({ tool, jobId, type, }) {
-    return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`);
+export async function fetchEbiResult({ tool, jobId, type, signal, }) {
+    return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`, { signal });
 }

package/dist/utils/fetch.d.ts

@@ -1,4 +1,11 @@
 export declare function handleFetch(url: string, args?: RequestInit): Promise<Response>;
 export declare function textfetch(url: string, args?: RequestInit): Promise<string>;
 export declare function jsonfetch<T>(url: string, args?: RequestInit): Promise<T>;
-export declare function timeout(time: number): Promise<unknown>;
+export declare function timeout(time: number, signal?: AbortSignal): Promise<void>;
+/**
+ * A cancelled launch has to be told apart from a failed one: it must not render
+ * the "failed" panel, and it must not touch a model that may already be gone.
+ * `fetch` and the sleep above both reject with a DOMException named AbortError,
+ * which subclasses Error.
+ */
+export declare function isAbortError(e: unknown): boolean;

package/dist/utils/fetch.js

@@ -36,6 +36,32 @@ export async function jsonfetch(url, args) {
     const response = await handleFetch(url, args);
     return response.json();
 }
-export function timeout(time) {
-    return new Promise(res => setTimeout(res, time));
+export function timeout(time, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DOMException('Aborted', 'AbortError'));
+            return;
+        }
+        // the listener is removed on the natural path too: one signal serves every
+        // tick of a poll, and a 10-minute job is ~600 sleeps -- leaving each
+        // listener behind accumulates them all on that one signal
+        const onAbort = () => {
+            clearTimeout(id);
+            reject(new DOMException('Aborted', 'AbortError'));
+        };
+        const id = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, time);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * A cancelled launch has to be told apart from a failed one: it must not render
+ * the "failed" panel, and it must not touch a model that may already be gone.
+ * `fetch` and the sleep above both reject with a DOMException named AbortError,
+ * which subclasses Error.
+ */
+export function isAbortError(e) {
+    return e instanceof Error && e.name === 'AbortError';
 }

package/dist/utils/msa.d.ts

@@ -7,14 +7,16 @@ import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts
  * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
  * a real distance matrix, Kimura-corrected for protein distances.
  */
-export declare function launchTree({ alignment, onProgress, }: {
+export declare function launchTree({ alignment, onProgress, signal, }: {
     alignment: string;
     onProgress: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<string>;
-export declare function launchMSA({ algorithm, sequence, onProgress, }: {
+export declare function launchMSA({ algorithm, sequence, onProgress, signal, }: {
     algorithm: MsaAlgorithm;
     sequence: string;
     onProgress: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     msa: string;
     tree: string;

package/dist/utils/msa.js

@@ -29,7 +29,7 @@ const algorithms = {
  * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
  * a real distance matrix, Kimura-corrected for protein distances.
  */
-export async function launchTree({ alignment, onProgress, }) {
+export async function launchTree({ alignment, onProgress, signal, }) {
     const tool = 'simple_phylogeny';
     onProgress('Building tree...');
     const jobId = await submitEbiJob({
@@ -40,34 +40,38 @@ export async function launchTree({ alignment, onProgress, }) {
             clustering: 'Neighbour-joining',
             kimura: 'true',
         },
+        signal,
     });
     await waitForEbiJob({
         tool,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking tree status in... ${s}`);
         },
     });
-    return fetchEbiResult({ tool, jobId, type: 'tree' });
+    return fetchEbiResult({ tool, jobId, type: 'tree', signal });
 }
-export async function launchMSA({ algorithm, sequence, onProgress, }) {
+export async function launchMSA({ algorithm, sequence, onProgress, signal, }) {
     const config = algorithms[algorithm];
     onProgress(`Launching ${algorithm} MSA...`);
     const jobId = await submitEbiJob({
         tool: algorithm,
         params: { ...config.params, sequence },
+        signal,
     });
     await waitForEbiJob({
         tool: algorithm,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking MSA status in... ${s}`);
         },
     });
     // one finished job, two result files, neither derived from the other
     const [msa, tree] = await Promise.all([
-        fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult }),
-        fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult }),
+        fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult, signal }),
+        fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult, signal }),
     ]);
     return { msa, tree };
 }

package/dist/utils/ncbiDomains.d.ts

@@ -5,11 +5,11 @@ export type DomainMatch = InterProScanResults['matches'][number];
  * domain and site annotations, keyed by both the versioned and primary
  * accession so callers can look up by whichever NCBI returned.
  */
-export declare function parseCddDomains(xml: string): Map<string, import("msa-parsers").InterProScanMatch[]>;
+export declare function parseCddDomains(xml: string): Map<string, DomainMatch[]>;
 /**
  * Fetch pre-computed CDD domain and site annotations for NCBI protein
  * accessions. These come baked into the GenPept records, so a single batched
  * efetch returns them with no job submission or polling. Results are cached in
  * IndexedDB so reopening a view doesn't refetch.
  */
-export declare function fetchProteinDomains(accessions: string[]): Promise<Map<string, import("msa-parsers").InterProScanMatch[]>>;
+export declare function fetchProteinDomains(accessions: string[]): Promise<Map<string, DomainMatch[]>>;

package/dist/utils/ncbiOrthologs.d.ts

@@ -10,6 +10,13 @@ export interface OrthologRow {
     protein: string;
     sequence: string;
 }
+/**
+ * A candidate gene reference as the ortholog services know it: a GFF ID prefix
+ * (gene:TP53) and a version suffix (NM_000546.6) stripped off. Shared with
+ * pantherOrthologs, which asks PANTHER the same question with the same
+ * candidates.
+ */
+export declare function cleanGeneCandidate(raw: string): 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.
@@ -50,7 +57,10 @@ 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.
+ * get a numeric suffix rather than silently overwriting a row, and the suffix
+ * climbs past labels already emitted: a species genuinely named `human_2` would
+ * otherwise take the label the second `human` is about to get, merging two rows
+ * into one.
  */
 export declare function dedupeLabels(names: string[]): string[];
 /**

package/dist/utils/ncbiOrthologs.js

@@ -53,6 +53,18 @@ function ncbiUrl(url) {
     const sep = url.includes('?') ? '&' : '?';
     return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
 }
+/**
+ * A candidate gene reference as the ortholog services know it: a GFF ID prefix
+ * (gene:TP53) and a version suffix (NM_000546.6) stripped off. Shared with
+ * pantherOrthologs, which asks PANTHER the same question with the same
+ * candidates.
+ */
+export function cleanGeneCandidate(raw) {
+    return raw
+        .trim()
+        .replace(/^\w+:/, '')
+        .replace(/\.\d+$/, '');
+}
 /**
  * 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.
@@ -69,8 +81,7 @@ export async function resolveGeneId(candidates, taxId) {
         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 cleaned = cleanGeneCandidate(query);
         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];
@@ -179,15 +190,23 @@ function sanitize(name) {
  * 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.
+ * get a numeric suffix rather than silently overwriting a row, and the suffix
+ * climbs past labels already emitted: a species genuinely named `human_2` would
+ * otherwise take the label the second `human` is about to get, merging two rows
+ * into one.
  */
 export function dedupeLabels(names) {
-    const seen = new Map();
+    const used = new Set();
     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}`;
+        let label = base;
+        let n = 1;
+        while (used.has(label)) {
+            n += 1;
+            label = `${base}_${n}`;
+        }
+        used.add(label);
+        return label;
     });
 }
 /**

package/dist/utils/ncbiOrthologs.test.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test, vi } from 'vitest';
-import { dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, } from './ncbiOrthologs';
+import { cleanGeneCandidate, dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, } from './ncbiOrthologs';
 describe('dedupeLabels', () => {
     test('sanitizes to single tokens', () => {
         // labels are used identically as FASTA headers, Newick leaf names and GFF
@@ -22,6 +22,28 @@ describe('dedupeLabels', () => {
     test('falls back for a name with no usable characters', () => {
         expect(dedupeLabels(['...', '...'])).toEqual(['row', 'row_2']);
     });
+    test('climbs past a suffix a literal name already took', () => {
+        // a label pairs a tree leaf to its alignment row, so handing the same one
+        // to two rows merges two species into one silently. The third label is ugly
+        // and unique, which is the trade
+        expect(dedupeLabels(['human', 'human', 'human_2'])).toEqual([
+            'human',
+            'human_2',
+            'human_2_2',
+        ]);
+        expect(dedupeLabels(['human_2', 'human', 'human'])).toEqual([
+            'human_2',
+            'human',
+            'human_3',
+        ]);
+    });
+});
+describe('cleanGeneCandidate', () => {
+    test('strips what a GFF feature carries that a gene lookup does not want', () => {
+        expect(cleanGeneCandidate(' gene:TP53 ')).toBe('TP53');
+        expect(cleanGeneCandidate('NM_000546.6')).toBe('NM_000546');
+        expect(cleanGeneCandidate('TP53')).toBe('TP53');
+    });
 });
 describe('parseFasta', () => {
     test('keys by the first header token and joins wrapped lines', () => {

package/dist/utils/pantherOrthologs.js

@@ -16,7 +16,7 @@
 // GenPept records with CDD Region features, so the overlay attaches as it does
 // to a RefSeq accession.
 import { jsonfetch } from './fetch';
-import { dedupeLabels, defaultMaxSpecies } from './ncbiOrthologs';
+import { cleanGeneCandidate, dedupeLabels, defaultMaxSpecies, } from './ncbiOrthologs';
 import { fetchTaxonomyInfo } from './taxonomyNames';
 const PANTHER = 'https://pantherdb.org/services/oai/pantherdb';
 const UNIPROT = 'https://rest.uniprot.org/uniprotkb';
@@ -122,14 +122,6 @@ async function fetchSequences(accessions) {
     }
     return map;
 }
-// strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53), as
-// resolveGeneId does for NCBI
-function cleanCandidate(raw) {
-    return raw
-        .trim()
-        .replace(/^\w+:/, '')
-        .replace(/\.\d+$/, '');
-}
 /**
  * One `matchortho` per candidate until PANTHER maps one. A JBrowse feature
  * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
@@ -139,7 +131,7 @@ function cleanCandidate(raw) {
 async function matchOrthologs(candidates, taxId, targets) {
     let matched;
     for (const raw of candidates) {
-        const query = cleanCandidate(raw);
+        const query = cleanGeneCandidate(raw);
         if (!query) {
             continue;
         }

package/dist/utils/phmmer.d.ts

@@ -37,11 +37,12 @@ export declare function parsePhmmerAlignment({ stockholm, query, }: {
     stockholm: string;
     query: string;
 }): PhmmerAlignment;
-export declare function queryPhmmer({ query, database, onProgress, onRid, }: {
+export declare function queryPhmmer({ query, database, onProgress, onRid, signal, }: {
     query: string;
     database: PhmmerDatabase;
     onProgress: (arg: string) => void;
     onRid: (arg: string) => void;
+    signal?: AbortSignal;
 }): Promise<{
     rows: PhmmerRow[];
     /**

package/dist/utils/phmmer.js

@@ -88,7 +88,7 @@ export function parsePhmmerAlignment({ stockholm, query, }) {
         })),
     };
 }
-export async function queryPhmmer({ query, database, onProgress, onRid, }) {
+export async function queryPhmmer({ query, database, onProgress, onRid, signal, }) {
     onProgress('Submitting to EBI phmmer...');
     const jobId = await submitEbiJob({
         tool: TOOL,
@@ -98,17 +98,19 @@ export async function queryPhmmer({ query, database, onProgress, onRid, }) {
             // the alignment is the whole point of using phmmer here
             alignView: 'true',
         },
+        signal,
     });
     onRid(jobId);
     await waitForEbiJob({
         tool: TOOL,
         jobId,
+        signal,
         onCountdown: s => {
             onProgress(`Re-checking phmmer status in... ${s}`);
         },
     });
     const alignment = parsePhmmerAlignment({
-        stockholm: await fetchEbiResult({ tool: TOOL, jobId, type: 'sto' }),
+        stockholm: await fetchEbiResult({ tool: TOOL, jobId, type: 'sto', signal }),
         query,
     });
     if (alignment.rows.length === 0) {

package/dist/utils/poll.d.ts

@@ -3,9 +3,14 @@
  * false when still pending, and throws on failure. Between checks it counts down
  * `intervalSeconds`, calling `onCountdown` each second so the UI can show
  * progress.
+ *
+ * `signal` ends the loop with an AbortError: the countdown rejects on the tick
+ * it is aborted rather than at the end of the interval, so a cancelled launch
+ * stops within a second instead of running for the job's lifetime.
  */
-export declare function pollLoop({ check, intervalSeconds, onCountdown, }: {
+export declare function pollLoop({ check, intervalSeconds, onCountdown, signal, }: {
     check: () => Promise<boolean>;
     intervalSeconds: number;
     onCountdown: (secondsRemaining: number) => void;
+    signal?: AbortSignal;
 }): Promise<void>;

package/dist/utils/poll.js

@@ -4,16 +4,21 @@ import { timeout } from './fetch';
  * false when still pending, and throws on failure. Between checks it counts down
  * `intervalSeconds`, calling `onCountdown` each second so the UI can show
  * progress.
+ *
+ * `signal` ends the loop with an AbortError: the countdown rejects on the tick
+ * it is aborted rather than at the end of the interval, so a cancelled launch
+ * stops within a second instead of running for the job's lifetime.
  */
-export async function pollLoop({ check, intervalSeconds, onCountdown, }) {
+export async function pollLoop({ check, intervalSeconds, onCountdown, signal, }) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
+        signal?.throwIfAborted();
         if (await check()) {
             return;
         }
         for (let i = intervalSeconds; i > 0; i--) {
             onCountdown(i);
-            await timeout(1000);
+            await timeout(1000, signal);
         }
     }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.4.0";
+export declare const version = "3.4.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '3.4.0';
+export const version = '3.4.1';