jbrowse-plugin-msaview 3.4.0 → 3.5.0

package/dist/LaunchMsaView/useQueryRowName.test.js

@@ -0,0 +1,23 @@
+// @vitest-environment jsdom
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { useQueryRowName } from './useQueryRowName';
+const protein = 'MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD';
+const trimmed = `>aligned_query\n${protein.slice(5, 45)}\n>other\nWRONGWRONGWRONGWRONGWRONGWRONGWRONGWRONG\n`;
+describe('useQueryRowName', () => {
+    test('carries the detected row and where it starts', () => {
+        const { result } = renderHook(() => useQueryRowName(trimmed, protein));
+        expect(result.current.querySeqName).toBe('aligned_query');
+        expect(result.current.querySeqOffset).toBe(5);
+    });
+    // the offset was measured against the detected row; another row is a row the
+    // user vouched for, and nothing here knows where in the protein it sits
+    test('a row the user picks instead is taken at face value', () => {
+        const { result } = renderHook(() => useQueryRowName(trimmed, protein));
+        act(() => {
+            result.current.setQuerySeqName('other');
+        });
+        expect(result.current.querySeqName).toBe('other');
+        expect(result.current.querySeqOffset).toBe(0);
+    });
+});

package/dist/LaunchMsaViewExtensionPoint/index.js

@@ -1,22 +1,34 @@
 import { launchMsaView } from '../utils/launchMsaView';
 export default function LaunchMsaViewExtensionPointF(pluginManager) {
     pluginManager.addToExtensionPoint('LaunchView-MsaView', (args) => {
-        const { session, data, msaFileLocation, msaIndexedLocation, msaName, treeFileLocation, querySeqName, ...rest } = args;
-        // `orthologParams` is a fourth source, and unlike the other three it names
-        // no alignment at all — the view builds one from NCBI at launch, which is
-        // the dialog's Orthologs tab reached declaratively.
+        const { session, data, msaFileLocation, msaIndexedLocation, msaName, treeFileLocation, querySeqName, searchParams, ...rest } = args;
+        // `orthologParams` and `searchParams` name no alignment at all — the
+        // view builds one at launch, which is the dialog's Orthologs and BLAST
+        // tabs reached declaratively.
         if (!data &&
             !msaFileLocation &&
             !msaIndexedLocation &&
-            !rest.orthologParams) {
-            throw new Error('No MSA data, file location or orthologParams provided when launching MSA view');
+            !rest.orthologParams &&
+            !searchParams) {
+            throw new Error('No MSA data, file location, orthologParams or searchParams provided when launching MSA view');
         }
         // inline data and the tree URL are native react-msaview snapshot props, set
         // 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,
+            ...(searchParams ? { blastParams: searchParams } : {}),
             data,
             ...(treeFileLocation
                 ? {
@@ -26,12 +38,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,64 @@
+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('searchParams is a source, stored under the name the dialog uses', () => {
+    const snapshot = launch({
+        searchParams: {
+            searchProgram: 'phmmer',
+            blastDatabase: 'rp15',
+            accession: 'P04637',
+        },
+        connectedViewId: 'lgv1',
+        connectedTranscript: 'NM_000546.6',
+    });
+    expect(snapshot.blastParams).toEqual({
+        searchProgram: 'phmmer',
+        blastDatabase: 'rp15',
+        accession: 'P04637',
+    });
+    expect('searchParams' in snapshot).toBe(false);
+    expect(snapshot.connectedTranscript).toBe('NM_000546.6');
+});
+test('a launch naming no source at all is refused', () => {
+    expect(() => launch({ connectedViewId: 'lgv1' })).toThrow(/searchParams/);
+});
+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,21 @@
 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 -- or from the indexed block its
+ * kept `init` names -- stores nothing at all: the file is the source of truth
+ * and it is refetched 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';
+import { getUniprotIdFromAlphaFoldUrl, hasQueryRow, transcriptPosToVisibleCol, } 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,67 @@ 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 -- or from the indexed block its
+ * kept `init` names -- stores nothing at all: the file is the source of truth
+ * and it is refetched 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, init } = self;
+    const data = currentData(self);
+    if (rows.length === 0 ||
+        isStoringData ||
+        self.msaFilehandle ||
+        self.treeFilehandle ||
+        // an indexed view keeps its init and refetches the block, so a row here
+        // would be one nothing ever reads
+        !!init?.msaIndexedLocation ||
+        !(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
@@ -78,43 +121,36 @@ export function storeDataToIndexedDB(self) {
  * until a new request replaces them.
  */
 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);
+    if (self.orthologParams && !awaitingTranscript(self)) {
+        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('');
-            }
-        })();
+            },
+        });
     }
 }
+/**
+ * A launch that names its transcript rather than its feature has to wait for
+ * the lookup: the query row is that transcript's translation, and the launch
+ * cannot start without a query. Both launchers read the same two fields, so
+ * the resolver setting `connectedFeature` is what refires them.
+ */
+function awaitingTranscript(self) {
+    return !!self.connectedTranscript && !self.connectedFeature;
+}
 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);
+    if (self.blastParams && !awaitingTranscript(self)) {
+        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('');
-            }
-        })();
+            },
+        });
     }
 }
 /**
@@ -144,15 +180,28 @@ export function autoLoadProteinDomains(self) {
         })();
     }
 }
-// Resolve the declarative `init` launch contract once, then clear it. msaUrl is
-// handed to react-msaview's native filehandle loader (openLocation + progress +
-// abort + CORS-proxy) and sniffed for an AlphaFold uniprotId; the bgzip
-// name-indexed block is the one source with no native loader, so it's fetched
-// here. Inline data and tree URLs arrive as native snapshot props, not via init.
+// Resolve the declarative `init` launch contract. msaUrl is handed to
+// react-msaview's native filehandle loader (openLocation + progress + abort +
+// CORS-proxy) and sniffed for an AlphaFold uniprotId; the bgzip name-indexed
+// block is the one source with no native loader, so it's fetched here. Inline
+// data and tree URLs arrive as native snapshot props, not via init.
+//
+// An init that named the indexed block is KEPT rather than cleared, as
+// jbrowse-plugin-tview keeps its own: what it resolves to is one alignment
+// string, react-msaview drops a document over 50kb from the snapshot, and there
+// is no filehandle to reload it from -- so a shared session came back saying the
+// alignment had expired. The init is both smaller than what it fetches and the
+// only durable statement of what the view is.
 export function processInit(self) {
     const { init } = self;
     if (init) {
         const { msaUrl, msaIndexedLocation, msaName, querySeqName } = init;
+        const indexed = !!(msaIndexedLocation && msaName);
+        // a kept init re-runs this on every session restore; the alignment already
+        // in hand is the one it would fetch
+        if (indexed && self.data.msa) {
+            return;
+        }
         void (async () => {
             try {
                 self.setError(undefined);
@@ -181,7 +230,9 @@ export function processInit(self) {
                         throw new Error(`No alignment named ${msaName} in ${msaIndexedLocation.uri}`);
                     }
                 }
-                self.setInit(undefined);
+                if (!indexed) {
+                    self.setInit(undefined);
+                }
             }
             catch (e) {
                 self.setError(e);
@@ -215,10 +266,10 @@ export function syncGenomeHoverToMsaColumn(self) {
  * Translate genome regions published by a 3D protein view into this MSA's
  * visible columns. The genome is the only coordinate space the two plugins
  * share, so the hops are genome coord -> protein position (the transcript's g2p
- * map) -> global alignment column -> visible column.
+ * map) -> visible column.
  */
 function genomeHighlightsToVisibleColumns(self, field) {
-    const { connectedViewId, transcriptToMsaMap, querySeqName } = self;
+    const { connectedViewId, transcriptToMsaMap } = self;
     if (!transcriptToMsaMap || !hasQueryRow(self)) {
         return [];
     }
@@ -232,16 +283,17 @@ function genomeHighlightsToVisibleColumns(self, field) {
             for (const highlight of structure[field] ?? []) {
                 for (let coord = highlight.start; coord < highlight.end; coord++) {
                     const proteinPos = g2p[coord];
-                    if (proteinPos !== undefined) {
-                        columns.add(self.seqPosToGlobalCol(querySeqName, proteinPos));
+                    const col = proteinPos === undefined
+                        ? undefined
+                        : transcriptPosToVisibleCol(self, proteinPos);
+                    if (col !== undefined) {
+                        columns.add(col);
                     }
                 }
             }
         }
     }
-    return [...columns]
-        .map(col => self.globalColToVisibleCol(col))
-        .filter((col) => col !== undefined);
+    return [...columns];
 }
 function sameColumns(a, b) {
     if (!a || !b) {

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
@@ -24,18 +29,31 @@ const LaunchProgress = observer(function LaunchProgress2({ model, }) {
     const { blastParams, orthologParams, progress, rid, error } = model;
     const { classes } = useStyles();
     const message = blastParams
-        ? 'Running EBI BLAST'
+        ? `Running EBI ${blastParams.searchProgram === 'phmmer' ? 'phmmer' : 'BLAST'}`
         : orthologParams
-            ? 'Building ortholog alignment'
+            ? orthologParams.source === 'uniref'
+                ? 'Building UniRef homolog alignment'
+                : 'Building ortholog alignment'
             : 'Loading alignment';
     return (React.createElement("div", { className: classes.margin }, error ? (React.createElement(React.Fragment, null,
         React.createElement(Typography, { variant: "h5" },
             message,
             " failed"),
         rid ? React.createElement(JobLink, { jobId: rid }) : null,
-        React.createElement(ErrorMessage, { error: error }))) : (React.createElement(React.Fragment, null,
+        React.createElement(ErrorMessage, { error: error }),
+        React.createElement("div", { className: classes.progressRow },
+            React.createElement(Button, { variant: "outlined", size: "small", onClick: () => {
+                    model.retryLaunch();
+                } }, "Retry"),
+            React.createElement(Button, { variant: "outlined", size: "small", onClick: () => {
+                    model.cancelLaunch();
+                } }, "Dismiss")))) : (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.js

@@ -14,8 +14,12 @@ const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     const { classes } = useStyles();
     const { blastParams, orthologParams, init, loadingStoredData } = model;
     // an unresolved launch request means there is no alignment to draw yet, so all
-    // three gate the same panel -- see LaunchProgress
-    const launching = !!(blastParams ?? orthologParams ?? init);
+    // three gate the same panel -- see LaunchProgress. An indexed view keeps its
+    // init for the life of the view (it is how the block is refetched), so that
+    // one is only "launching" until the alignment arrives.
+    const launching = !!(blastParams ??
+        orthologParams ??
+        (init && !model.dataInitialized));
     return (React.createElement(ErrorBoundary, null,
         React.createElement("div", null, launching ? (React.createElement(LaunchProgress, { model: model })) : loadingStoredData ? (React.createElement("div", { className: classes.loadingContainer },
             React.createElement(LoadingEllipses, { message: "Loading MSA data", variant: "h6" }))) : (React.createElement(MSAView, { model: model })))));

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

@@ -48,6 +48,16 @@ test('a failed ortholog launch shows why', () => {
     });
     expect(screen.getByText(/Only 1 ortholog\(s\) found/)).toBeTruthy();
 });
+// an indexed view keeps its init -- it is how the block is refetched on the
+// next session -- so the panel cannot read init alone as "still launching"
+test('an indexed view with its alignment draws it, init and all', () => {
+    panel({
+        init: { msaIndexedLocation: { uri: 'msa.fa.gz' }, msaName: 'ENST1' },
+        dataInitialized: true,
+        progress: '',
+    });
+    expect(screen.getByText('the alignment')).toBeTruthy();
+});
 test('a failed init shows why', () => {
     panel({
         init: { msaName: 'ENST00000288602' },
@@ -57,6 +67,36 @@ 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', () => {
+    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();
+});
+// the request outlives the failure -- it is what a reload resubmits -- so a
+// failed launch that only drew the error was a dead end that re-ran the EBI job
+// on every reload
+test('a failed launch can be retried or dismissed', () => {
+    const cancelLaunch = vi.fn();
+    const retryLaunch = vi.fn();
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: '',
+        error: new Error('No hits found'),
+        cancelLaunch,
+        retryLaunch,
+    });
+    expect(screen.queryByRole('button', { name: 'Cancel' })).toBeNull();
+    screen.getByRole('button', { name: 'Retry' }).click();
+    expect(retryLaunch).toHaveBeenCalled();
+    screen.getByRole('button', { name: 'Dismiss' }).click();
+    expect(cancelLaunch).toHaveBeenCalled();
+});
 test('a running job links out to it', () => {
     panel({
         blastParams: { proteinSequence: 'MKV' },

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -1,6 +1,16 @@
 import type { JBrowsePluginMsaViewModel } from './model';
-export declare function doLaunchBlast({ self, }: {
+import type { LaunchScope } from './runLaunch';
+/**
+ * A similarity search, then an alignment of what it found. The program is a
+ * backend behind one interface (utils/homologSearch.ts); what differs between
+ * them is settled by whether the result came back aligned. A program that
+ * aligns as it searches (phmmer) hands over the alignment and the tree is
+ * built from it in the browser; one that does not (blastp) hands over bare
+ * hits and the chosen aligner runs on them.
+ */
+export declare function doLaunchBlast({ self, scope, }: {
     self: JBrowsePluginMsaViewModel;
+    scope: LaunchScope;
 }): Promise<{
     msa: string;
     tree: string;