jbrowse-plugin-msaview 3.4.0 → 3.4.1

package/dist/LaunchMsaView/components/BlastQuery/BlastAutomaticPanel.js

@@ -12,7 +12,8 @@ import { useTranscriptSelection } from '../useTranscriptSelection';
 import CachedBlastResults from './CachedBlastResults';
 import MsaAlgorithmSelect from './MsaAlgorithmSelect';
 import { blastLaunchView } from './blastLaunchView';
-import { databaseOptionsFor, defaultBlastDatabase, defaultSearchFor, searchPrograms, } from './consts';
+import { databaseOptionsFor, defaultSearchFor, searchPrograms } from './consts';
+import { useStoredMsaAlgorithm, useStoredSearchChoice, } from './searchChoiceStorage';
 import { useCachedBlastResults } from './useCachedBlastResults';
 const useStyles = makeStyles()({
     selectField: {
@@ -38,11 +39,8 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
     // one piece of state, not two: a program and a database that program does not
     // have is a 400 from EBI minutes after Submit, and holding them apart is what
     // would let them drift into that
-    const [search, setSearch] = useState({
-        program: 'blastp',
-        database: defaultBlastDatabase,
-    });
-    const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useState('clustalo');
+    const [search, setSearch] = useStoredSearchChoice();
+    const [selectedMsaAlgorithm, setSelectedMsaAlgorithm] = useStoredMsaAlgorithm();
     const isPhmmer = search.program === 'phmmer';
     const geneIds = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const { results: cachedResults, error: cachedResultsError } = useCachedBlastResults(geneIds);

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.d.ts

@@ -0,0 +1,7 @@
+import type { MsaAlgorithm, SearchChoice } from './consts';
+export declare const SEARCH_CHOICE_STORAGE_KEY = "msaView-blastSearch";
+export declare const MSA_ALGORITHM_STORAGE_KEY = "msaView-msaAlgorithm";
+export declare function validSearchChoice(stored: unknown): SearchChoice;
+export declare function validMsaAlgorithm(stored: unknown): MsaAlgorithm;
+export declare function useStoredSearchChoice(): readonly [SearchChoice, (choice: SearchChoice) => void];
+export declare function useStoredMsaAlgorithm(): readonly ["clustalo" | "muscle" | "kalign" | "mafft", (algorithm: MsaAlgorithm) => void];

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.js

@@ -0,0 +1,42 @@
+import { useLocalStorage } from '../../../utils/useLocalStorage';
+import { databaseOptionsFor, defaultSearchFor, msaAlgorithms, searchPrograms, } from './consts';
+// The panel reopens on the last search run rather than on the defaults, the way
+// the Orthologs tab remembers its source.
+//
+// The program and its database stay ONE stored value for the reason consts.ts
+// keeps them one state: neither service knows the other's database names. What
+// comes back is checked against the current options before it is used — an
+// option this plugin has since dropped would otherwise reach EBI and come back
+// a 400, minutes after the user pressed Submit.
+export const SEARCH_CHOICE_STORAGE_KEY = 'msaView-blastSearch';
+export const MSA_ALGORITHM_STORAGE_KEY = 'msaView-msaAlgorithm';
+const defaultSearch = defaultSearchFor('blastp');
+const defaultMsaAlgorithm = 'clustalo';
+export function validSearchChoice(stored) {
+    const { program, database } = (stored ?? {});
+    const known = searchPrograms.find(p => p === program);
+    return known && databaseOptionsFor(known).some(d => d === database)
+        ? { program: known, database }
+        : defaultSearch;
+}
+export function validMsaAlgorithm(stored) {
+    return msaAlgorithms.find(a => a === stored) ?? defaultMsaAlgorithm;
+}
+export function useStoredSearchChoice() {
+    const [stored, setStored] = useLocalStorage(SEARCH_CHOICE_STORAGE_KEY, defaultSearch);
+    return [
+        validSearchChoice(stored),
+        (choice) => {
+            setStored(choice);
+        },
+    ];
+}
+export function useStoredMsaAlgorithm() {
+    const [stored, setStored] = useLocalStorage(MSA_ALGORITHM_STORAGE_KEY, defaultMsaAlgorithm);
+    return [
+        validMsaAlgorithm(stored),
+        (algorithm) => {
+            setStored(algorithm);
+        },
+    ];
+}

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.test.d.ts

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

package/dist/LaunchMsaView/components/BlastQuery/searchChoiceStorage.test.js

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest';
+import { validMsaAlgorithm, validSearchChoice } from './searchChoiceStorage';
+test('a stored pair both services recognise comes back as it went in', () => {
+    expect(validSearchChoice({ program: 'phmmer', database: 'swissprot' })).toEqual({
+        program: 'phmmer',
+        database: 'swissprot',
+    });
+});
+test('a database the stored program does not have falls back to the defaults', () => {
+    // uniprotkb_swissprot is blastp's name for it; sending it to phmmer is a 400
+    // from EBI minutes after Submit
+    expect(validSearchChoice({ program: 'phmmer', database: 'uniprotkb_swissprot' })).toEqual({ program: 'blastp', database: 'uniprotkb_swissprot' });
+    // uniprotkb_reference_proteomes shipped as a menu entry EBI rejects, and 3.0.0
+    // is old enough that someone's storage still holds it
+    expect(validSearchChoice({
+        program: 'blastp',
+        database: 'uniprotkb_reference_proteomes',
+    })).toEqual({ program: 'blastp', database: 'uniprotkb_swissprot' });
+});
+test('storage holding something else entirely falls back rather than throwing', () => {
+    for (const stored of [null, undefined, 'blastp', 42, {}, []]) {
+        expect(validSearchChoice(stored)).toEqual({
+            program: 'blastp',
+            database: 'uniprotkb_swissprot',
+        });
+    }
+});
+test('an unknown algorithm falls back to clustalo', () => {
+    expect(validMsaAlgorithm('mafft')).toBe('mafft');
+    expect(validMsaAlgorithm('t_coffee')).toBe('clustalo');
+    expect(validMsaAlgorithm(null)).toBe('clustalo');
+});

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -7,6 +7,7 @@ import { defaultMaxSpecies } from '../../../utils/ncbiOrthologs';
 import { useLocalStorage } from '../../../utils/useLocalStorage';
 import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
 import MsaAlgorithmSelect from '../BlastQuery/MsaAlgorithmSelect';
+import { useStoredMsaAlgorithm } from '../BlastQuery/searchChoiceStorage';
 import LaunchPanelContent from '../LaunchPanelContent';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
@@ -25,7 +26,7 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const [launchViewError, setLaunchViewError] = useState();
     const [taxId, setTaxId] = useState(9606);
     const [source, setSource] = useLocalStorage(ORTHOLOG_SOURCE_STORAGE_KEY, 'ncbi');
-    const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
+    const [msaAlgorithm, setMsaAlgorithm] = useStoredMsaAlgorithm();
     const [maxSpecies, setMaxSpecies] = useState(String(defaultMaxSpecies));
     const geneCandidates = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const transcriptSelection = useTranscriptSelection({ feature, view });

package/dist/LaunchMsaViewExtensionPoint/index.js

@@ -15,6 +15,16 @@ export default function LaunchMsaViewExtensionPointF(pluginManager) {
         // directly, and so is orthologParams (the model's own autorun picks it up).
         // Only sources needing launch-time resolution go through `init`: msaUrl
         // (AlphaFold sniff) and the name-indexed bgzip block (no native loader).
+        //
+        // An init whose every field is undefined is still a truthy object, and
+        // MsaViewPanel reads any init as a launch in flight, so an inline-data
+        // launch flashed "Loading alignment" until processInit cleared it.
+        const init = {
+            msaUrl: msaFileLocation?.uri,
+            msaIndexedLocation,
+            msaName,
+            querySeqName,
+        };
         launchMsaView(session, {
             ...rest,
             data,
@@ -26,12 +36,7 @@ export default function LaunchMsaViewExtensionPointF(pluginManager) {
                     },
                 }
                 : {}),
-            init: {
-                msaUrl: msaFileLocation?.uri,
-                msaIndexedLocation,
-                msaName,
-                querySeqName,
-            },
+            ...(Object.values(init).some(v => v !== undefined) ? { init } : {}),
         });
         return args;
     });

package/dist/LaunchMsaViewExtensionPoint/index.test.d.ts

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

package/dist/LaunchMsaViewExtensionPoint/index.test.js

@@ -0,0 +1,43 @@
+import { expect, test } from 'vitest';
+import LaunchMsaViewExtensionPointF from './index';
+function launch(args) {
+    let run;
+    LaunchMsaViewExtensionPointF({
+        addToExtensionPoint(_name, cb) {
+            run = cb;
+        },
+    });
+    const added = [];
+    const session = {
+        addView(_type, snapshot) {
+            added.push(snapshot);
+            return { id: 'view-1' };
+        },
+    };
+    run({ session, ...args });
+    return added[0];
+}
+test('inline data carries no init, which the panel would read as a launch in flight', () => {
+    const snapshot = launch({ data: { msa: '>a\nMEEP' } });
+    expect('init' in snapshot).toBe(false);
+});
+test('a file location travels through init', () => {
+    const snapshot = launch({
+        msaFileLocation: { uri: 'http://example.com/a.fa' },
+    });
+    expect(snapshot.init).toEqual({
+        msaUrl: 'http://example.com/a.fa',
+        msaIndexedLocation: undefined,
+        msaName: undefined,
+        querySeqName: undefined,
+    });
+});
+test('one field set is enough to need init', () => {
+    const snapshot = launch({ data: { msa: '>a\nMEEP' }, querySeqName: 'QUERY' });
+    expect(snapshot.init).toEqual({
+        msaUrl: undefined,
+        msaIndexedLocation: undefined,
+        msaName: undefined,
+        querySeqName: 'QUERY',
+    });
+});

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -1,5 +1,20 @@
 import type { JBrowsePluginMsaViewModel } from './model';
 export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
+/**
+ * Keep IndexedDB holding what the view holds. The first run writes a new row and
+ * records its id in the session snapshot; later runs update that row, because
+ * the alignment keeps changing after it arrives — react-msaview's
+ * "calculate neighbor-joining tree" replaces `data.tree` — and a session
+ * reopened against a stale row restores the wrong picture.
+ *
+ * `lastStoredData` is what makes that safe to run on every data change: it is
+ * the only thing separating "this is new" from "this is what we just wrote", and
+ * it is recorded whether or not the write succeeded, so a browser refusing
+ * IndexedDB (private mode) fails once rather than in a loop.
+ *
+ * A view whose data comes from a filehandle stores nothing at all: the file is
+ * the source of truth and react-msaview refetches it at startup.
+ */
 export declare function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel): void;
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -1,12 +1,15 @@
 import { getSession } from '@jbrowse/core/util';
+import { transaction } from 'mobx';
 import { doLaunchBlast } from './doLaunchBlast';
 import { doLaunchOrthologs } from './doLaunchOrthologs';
 import { fetchIndexedMsa } from './fetchIndexedMsa';
 import { genomeToMSA } from './genomeToMSA';
 import { loadProteinDomains } from './loadProteinDomains';
 import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
+import { runLaunch } from './runLaunch';
 import { getProteinViews } from './structureConnection';
 import { getUniprotIdFromAlphaFoldUrl, hasQueryRow } from './util';
+const EXPIRED_MESSAGE = "This view's alignment is no longer in browser storage. Stored alignments are kept for 7 days after they were last used, and are lost when site data is cleared. Relaunch the alignment to rebuild it.";
 export function loadStoredData(self) {
     const { dataStoreId, rows } = self;
     if (dataStoreId && rows.length === 0) {
@@ -15,15 +18,28 @@ export function loadStoredData(self) {
                 self.setLoadingStoredData(true);
                 const storedData = await retrieveMsaData(dataStoreId);
                 if (storedData) {
-                    if (storedData.msa) {
-                        self.setMSA(storedData.msa);
-                    }
-                    if (storedData.tree) {
-                        self.setTree(storedData.tree);
-                    }
-                    if (storedData.treeMetadata) {
-                        self.setTreeMetadata(storedData.treeMetadata);
-                    }
+                    // one transaction, so storeDataToIndexedDB sees the restored data and
+                    // the record of it together and does not write it straight back
+                    transaction(() => {
+                        if (storedData.msa) {
+                            self.setMSA(storedData.msa);
+                        }
+                        if (storedData.tree) {
+                            self.setTree(storedData.tree);
+                        }
+                        if (storedData.treeMetadata) {
+                            self.setTreeMetadata(storedData.treeMetadata);
+                        }
+                        self.setLastStoredData(currentData(self));
+                    });
+                }
+                else {
+                    // the id names nothing, so clearing it is what lets react-msaview's
+                    // "Return to import form" actually return instead of landing back here
+                    transaction(() => {
+                        self.setDataStoreId(undefined);
+                        self.setError(new Error(EXPIRED_MESSAGE));
+                    });
                 }
             }
             catch (e) {
@@ -35,40 +51,63 @@ export function loadStoredData(self) {
         })();
     }
 }
+function currentData(self) {
+    const { msa, tree, treeMetadata } = self.data;
+    return { msa, tree, treeMetadata };
+}
+function sameData(a, b) {
+    return (!!a &&
+        a.msa === b.msa &&
+        a.tree === b.tree &&
+        a.treeMetadata === b.treeMetadata);
+}
+/**
+ * Keep IndexedDB holding what the view holds. The first run writes a new row and
+ * records its id in the session snapshot; later runs update that row, because
+ * the alignment keeps changing after it arrives — react-msaview's
+ * "calculate neighbor-joining tree" replaces `data.tree` — and a session
+ * reopened against a stale row restores the wrong picture.
+ *
+ * `lastStoredData` is what makes that safe to run on every data change: it is
+ * the only thing separating "this is new" from "this is what we just wrote", and
+ * it is recorded whether or not the write succeeded, so a browser refusing
+ * IndexedDB (private mode) fails once rather than in a loop.
+ *
+ * A view whose data comes from a filehandle stores nothing at all: the file is
+ * the source of truth and react-msaview refetches it at startup.
+ */
 export function storeDataToIndexedDB(self) {
-    const { rows, dataStoreId, isStoringData } = self;
-    if (rows.length > 0 && !dataStoreId && !isStoringData) {
-        if (self.msaFilehandle || self.treeFilehandle) {
-            return;
+    const { rows, dataStoreId, isStoringData, lastStoredData } = self;
+    const data = currentData(self);
+    if (rows.length === 0 ||
+        isStoringData ||
+        self.msaFilehandle ||
+        self.treeFilehandle ||
+        !(data.msa || data.tree) ||
+        sameData(lastStoredData, data)) {
+        return;
+    }
+    // mark as storing synchronously so re-runs of this autorun (e.g. when data
+    // observables change while the write is pending) don't kick off a duplicate
+    // write and leave an orphan IndexedDB entry
+    self.setIsStoringData(true);
+    void (async () => {
+        try {
+            const id = dataStoreId ?? generateDataStoreId();
+            if (await storeMsaData(id, data)) {
+                self.setDataStoreId(id);
+            }
         }
-        const msaData = self.data.msa;
-        const treeData = self.data.tree;
-        if (msaData || treeData) {
-            // mark as storing synchronously so re-runs of this autorun (e.g. when
-            // data observables change while the write is pending) don't kick off a
-            // duplicate write and leave an orphan IndexedDB entry
-            self.setIsStoringData(true);
-            void (async () => {
-                try {
-                    const newId = generateDataStoreId();
-                    const success = await storeMsaData(newId, {
-                        msa: msaData,
-                        tree: treeData,
-                        treeMetadata: self.data.treeMetadata,
-                    });
-                    if (success) {
-                        self.setDataStoreId(newId);
-                    }
-                }
-                catch (e) {
-                    console.error('Failed to store MSA data to IndexedDB:', e);
-                }
-                finally {
-                    self.setIsStoringData(false);
-                }
-            })();
+        catch (e) {
+            console.error('Failed to store MSA data to IndexedDB:', e);
         }
-    }
+        finally {
+            transaction(() => {
+                self.setLastStoredData(data);
+                self.setIsStoringData(false);
+            });
+        }
+    })();
 }
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
@@ -79,42 +118,26 @@ export function storeDataToIndexedDB(self) {
  */
 export function launchOrthologsIfNeeded(self) {
     if (self.orthologParams) {
-        void (async () => {
-            try {
-                self.setProgress('Resolving orthologs');
-                self.setError(undefined);
-                const data = await doLaunchOrthologs({ self });
-                self.setData(data);
+        runLaunch({
+            self,
+            message: 'Resolving orthologs',
+            launch: scope => doLaunchOrthologs({ self, scope }),
+            onLaunched: () => {
                 self.setOrthologParams(undefined);
-            }
-            catch (e) {
-                self.setError(e);
-                console.error(e);
-            }
-            finally {
-                self.setProgress('');
-            }
-        })();
+            },
+        });
     }
 }
 export function launchBlastIfNeeded(self) {
     if (self.blastParams) {
-        void (async () => {
-            try {
-                self.setProgress('Submitting query');
-                self.setError(undefined);
-                const data = await doLaunchBlast({ self });
-                self.setData(data);
+        runLaunch({
+            self,
+            message: 'Submitting query',
+            launch: scope => doLaunchBlast({ self, scope }),
+            onLaunched: () => {
                 self.setBlastParams(undefined);
-            }
-            catch (e) {
-                self.setError(e);
-                console.error(e);
-            }
-            finally {
-                self.setProgress('');
-            }
-        })();
+            },
+        });
     }
 }
 /**

package/dist/MsaViewPanel/components/LaunchProgress.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import { ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
-import { Typography } from '@mui/material';
+import { Button, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
 import JobLink from './JobLink';
@@ -8,6 +8,11 @@ const useStyles = makeStyles()({
     margin: {
         padding: 20,
     },
+    progressRow: {
+        display: 'flex',
+        alignItems: 'center',
+        gap: 12,
+    },
 });
 /**
  * What a view shows while it is still building its alignment, and what it shows
@@ -36,6 +41,10 @@ const LaunchProgress = observer(function LaunchProgress2({ model, }) {
         React.createElement(ErrorMessage, { error: error }))) : (React.createElement(React.Fragment, null,
         React.createElement(LoadingEllipses, { message: message, variant: "h5" }),
         rid ? React.createElement(JobLink, { jobId: rid }) : null,
-        React.createElement(Typography, null, progress || 'Initializing')))));
+        React.createElement("div", { className: classes.progressRow },
+            React.createElement(Typography, null, progress || 'Initializing'),
+            React.createElement(Button, { variant: "outlined", size: "small", onClick: () => {
+                    model.cancelLaunch();
+                } }, "Cancel"))))));
 });
 export default LaunchProgress;

package/dist/MsaViewPanel/components/MsaViewPanel.test.js

@@ -57,6 +57,25 @@ test('a failed init shows why', () => {
     expect(screen.queryByText('the alignment')).toBeNull();
     expect(screen.getByText(/No alignment named ENST00000288602/)).toBeTruthy();
 });
+// a launch runs for 10+ minutes, so leaving with no way out means watching it
+test('a running launch offers a way out, and a failed one does not', () => {
+    const cancelLaunch = vi.fn();
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: 'Re-checking BLAST status in... 7',
+        cancelLaunch,
+    });
+    screen.getByRole('button', { name: 'Cancel' }).click();
+    expect(cancelLaunch).toHaveBeenCalled();
+    cleanup();
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: '',
+        error: new Error('No hits found'),
+        cancelLaunch,
+    });
+    expect(screen.queryByRole('button', { name: 'Cancel' })).toBeNull();
+});
 test('a running job links out to it', () => {
     panel({
         blastParams: { proteinSequence: 'MKV' },

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -1,6 +1,8 @@
 import type { JBrowsePluginMsaViewModel } from './model';
-export declare function doLaunchBlast({ self, }: {
+import type { LaunchScope } from './runLaunch';
+export declare function doLaunchBlast({ self, scope, }: {
     self: JBrowsePluginMsaViewModel;
+    scope: LaunchScope;
 }): Promise<{
     msa: string;
     tree: string;

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -6,26 +6,20 @@ import { launchMSA, launchTree } from '../utils/msa';
 import { buildPhmmerMsa, buildRowMetadata } from '../utils/msaRows';
 import { queryPhmmer } from '../utils/phmmer';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
-export async function doLaunchBlast({ self, }) {
+export async function doLaunchBlast({ self, scope, }) {
     // kept whole rather than destructured: the database's type depends on
     // searchProgram, and pulling the two apart loses the link between them
     const params = self.blastParams;
     const { selectedTranscript } = params;
     const cleanedSeq = cleanProteinSequence(params.proteinSequence);
-    const onProgress = (arg) => {
-        self.setProgress(arg);
-    };
-    // publish the job id before the first poll so the view can link out while the
-    // job is still running
-    const onRid = (r) => {
-        self.setRid(r);
-    };
+    const { onProgress, onRid, signal } = scope;
     const { msa, tree, treeMetadata, rid } = params.searchProgram === 'phmmer'
         ? await runPhmmer({
             query: cleanedSeq,
             database: params.blastDatabase,
             onProgress,
             onRid,
+            signal,
         })
         : await runBlast({
             query: cleanedSeq,
@@ -33,6 +27,7 @@ export async function doLaunchBlast({ self, }) {
             msaAlgorithm: params.msaAlgorithm,
             onProgress,
             onRid,
+            signal,
         });
     const treeMetadataJson = JSON.stringify(treeMetadata);
     await saveBlastResult({
@@ -57,12 +52,13 @@ export async function doLaunchBlast({ self, }) {
  * at a time, so the alignments are stripped back off and every hit is realigned
  * together by a dedicated aligner.
  */
-async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid, }) {
+async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid, signal, }) {
     const { hits, rid } = await queryEbiBlast({
         query,
         blastDatabase,
         onProgress,
         onRid,
+        signal,
     });
     onProgress('Fetching species taxonomy info...');
     const taxonomyInfo = await fetchTaxonomyInfo(hits
@@ -83,6 +79,7 @@ async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid,
         algorithm: msaAlgorithm,
         sequence: [`>QUERY\n${query}`, ...sequences].join('\n'),
         onProgress,
+        signal,
     });
     return { ...result, treeMetadata, rid };
 }
@@ -93,12 +90,13 @@ async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid,
  * match columns rather than being aligned back in afterwards. That leaves no
  * aligner run to take a tree from, so the tree is built from this alignment.
  */
-async function runPhmmer({ query, database, onProgress, onRid, }) {
+async function runPhmmer({ query, database, onProgress, onRid, signal, }) {
     const { rows, queryRow, rid } = await queryPhmmer({
         query,
         database,
         onProgress,
         onRid,
+        signal,
     });
     onProgress('Fetching species taxonomy info...');
     const taxonomyInfo = await fetchTaxonomyInfo(rows.map(r => r.taxid).filter((t) => t !== undefined));
@@ -109,7 +107,7 @@ async function runPhmmer({ query, database, onProgress, onRid, }) {
     });
     return {
         msa,
-        tree: await launchTree({ alignment: msa, onProgress }),
+        tree: await launchTree({ alignment: msa, onProgress, signal }),
         treeMetadata,
         rid,
     };

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -1,4 +1,5 @@
 import type { JBrowsePluginMsaViewModel } from './model';
+import type { LaunchScope } from './runLaunch';
 /**
  * The no-search-job alternative to doLaunchBlast.
  *
@@ -16,8 +17,9 @@ import type { JBrowsePluginMsaViewModel } from './model';
  * would silently break the genome<->MSA linkage. The query species is therefore
  * excluded from the ortholog set rather than appearing twice.
  */
-export declare function doLaunchOrthologs({ self, }: {
+export declare function doLaunchOrthologs({ self, scope, }: {
     self: JBrowsePluginMsaViewModel;
+    scope: LaunchScope;
 }): Promise<{
     treeMetadata: string;
     msa: string;

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -20,11 +20,9 @@ import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
  * would silently break the genome<->MSA linkage. The query species is therefore
  * excluded from the ortholog set rather than appearing twice.
  */
-export async function doLaunchOrthologs({ self, }) {
+export async function doLaunchOrthologs({ self, scope, }) {
     const { taxId, taxa, maxSpecies, geneCandidates, msaAlgorithm, proteinSequence, source = 'ncbi', } = self.orthologParams;
-    const onProgress = (arg) => {
-        self.setProgress(arg);
-    };
+    const { onProgress, act, signal } = scope;
     const request = {
         taxId,
         geneCandidates,
@@ -62,7 +60,9 @@ export async function doLaunchOrthologs({ self, }) {
     // token, and a collision would silently point the coordinate mapping at
     // another animal's row.
     const queryLabel = await queryRowLabel(taxId, rows);
-    self.setQuerySeqName(queryLabel);
+    act(() => {
+        self.setQuerySeqName(queryLabel);
+    });
     const treeMetadata = {
         [queryLabel]: buildQueryMetadata(self, geneId, cleanedSeq, representative),
     };
@@ -76,6 +76,7 @@ export async function doLaunchOrthologs({ self, }) {
             ...rows.map(r => `>${r.label}\n${r.sequence}`),
         ].join('\n'),
         onProgress,
+        signal,
     });
     return {
         ...result,