jbrowse-plugin-msaview 3.3.0 → 3.4.1

package/dist/LaunchMsaView/detectQueryRow.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { detectQueryRow, getMsaRowNames } from './detectQueryRow';
+import { findQueryRow } from './detectQueryRow';
 const protein = 'MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD';
 // COBALT renames the query `Query_1`, so only the residues identify it
 const clustal = `CLUSTAL W (1.81) multiple sequence alignment
@@ -13,22 +13,22 @@ MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD
 >sp|P02769|ALBU_BOVIN
 MKWVTFISLLLLFSSAYSRG--RRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPYD
 `;
-describe('detectQueryRow', () => {
+describe('findQueryRow', () => {
     test('finds the query by sequence when the aligner renamed it', () => {
-        expect(detectQueryRow(clustal, protein)).toMatchObject({
+        expect(findQueryRow(clustal, protein).match).toMatchObject({
             name: 'Query_1',
             quality: 'exact',
         });
     });
     test('ignores gaps in the aligned row', () => {
-        expect(detectQueryRow(fasta, protein)?.name).toBe('Query_1');
+        expect(findQueryRow(fasta, protein).match?.name).toBe('Query_1');
     });
     test('tolerates the trailing stop codon the translation carries', () => {
-        expect(detectQueryRow(clustal, `${protein}*`)?.name).toBe('Query_1');
+        expect(findQueryRow(clustal, `${protein}*`).match?.name).toBe('Query_1');
     });
     test('matches a row that is the query trimmed to the aligned region', () => {
         const trimmed = `>hit_one\nWRONGWRONGWRONGWRONG\n>aligned_query\n${protein.slice(5, 40)}\n`;
-        expect(detectQueryRow(trimmed, protein)).toMatchObject({
+        expect(findQueryRow(trimmed, protein).match).toMatchObject({
             name: 'aligned_query',
             quality: 'partial',
         });
@@ -41,25 +41,25 @@ MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD
 >hit_two
 MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD
 `;
-        expect(detectQueryRow(homologsOnly, 'WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW')).toBeUndefined();
+        expect(findQueryRow(homologsOnly, 'WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW').match).toBeUndefined();
     });
     test('returns nothing rather than throwing on a half-pasted alignment', () => {
-        expect(detectQueryRow('>partial\nMKWV', protein)).toBeUndefined();
-        expect(detectQueryRow('not an alignment at all', protein)).toBeUndefined();
-        expect(detectQueryRow('', protein)).toBeUndefined();
-        expect(detectQueryRow(clustal, '')).toBeUndefined();
+        expect(findQueryRow('>partial\nMKWV', protein).match).toBeUndefined();
+        expect(findQueryRow('not an alignment at all', protein).match).toBeUndefined();
+        expect(findQueryRow('', protein).match).toBeUndefined();
+        expect(findQueryRow(clustal, '').match).toBeUndefined();
     });
 });
-describe('getMsaRowNames', () => {
+describe('findQueryRow row names', () => {
     test('lists the rows for the override dropdown', () => {
-        expect(getMsaRowNames(clustal)).toEqual([
+        expect(findQueryRow(clustal, protein).names).toEqual([
             'Query_1',
             'sp|P02769|ALBU',
             'sp|Q5XLE4|OTHE',
         ]);
     });
     test('is empty rather than throwing while the user is still pasting', () => {
-        expect(getMsaRowNames('CLUSTAL W')).toEqual([]);
-        expect(getMsaRowNames('')).toEqual([]);
+        expect(findQueryRow('CLUSTAL W', protein).names).toEqual([]);
+        expect(findQueryRow('', protein).names).toEqual([]);
     });
 });

package/dist/LaunchMsaView/useQueryRowName.js

@@ -1,5 +1,5 @@
 import { useMemo, useState } from 'react';
-import { detectQueryRow, getMsaRowNames } from './detectQueryRow';
+import { findQueryRow } from './detectQueryRow';
 /**
  * The MSA row name to launch with, found by sequence rather than typed.
  *
@@ -12,15 +12,12 @@ export function useQueryRowName(msaText, proteinSequence) {
     const [override, setOverride] = useState();
     // parsing runs on every keystroke in the paste box otherwise, and an
     // alignment of a few hundred rows is not free
-    const { detected, names } = useMemo(() => ({
-        detected: detectQueryRow(msaText, proteinSequence),
-        names: getMsaRowNames(msaText),
-    }), [msaText, proteinSequence]);
+    const { names, match } = useMemo(() => findQueryRow(msaText, proteinSequence), [msaText, proteinSequence]);
     return {
-        detected,
+        detected: match,
         names,
-        querySeqName: override ?? detected?.name ?? '',
+        querySeqName: override ?? match?.name ?? '',
         setQuerySeqName: setOverride,
-        isAutoDetected: override === undefined && !!detected,
+        isAutoDetected: override === undefined && !!match,
     };
 }

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 } from './util';
+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('');
-            }
-        })();
+            },
+        });
     }
 }
 /**
@@ -219,7 +242,7 @@ export function syncGenomeHoverToMsaColumn(self) {
  */
 function genomeHighlightsToVisibleColumns(self, field) {
     const { connectedViewId, transcriptToMsaMap, querySeqName } = self;
-    if (!transcriptToMsaMap) {
+    if (!transcriptToMsaMap || !hasQueryRow(self)) {
         return [];
     }
     const { g2p } = transcriptToMsaMap;

package/dist/MsaViewPanel/components/ErrorBoundary.d.ts

@@ -1,5 +1,5 @@
-import type { ReactNode } from 'react';
 import React, { Component } from 'react';
+import type { ReactNode } from 'react';
 interface Props {
     children: ReactNode;
 }
@@ -14,6 +14,6 @@ export declare class ErrorBoundary extends Component<Props, State> {
         error: unknown;
     };
     componentDidCatch(error: unknown, info: React.ErrorInfo): void;
-    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 export {};

package/dist/MsaViewPanel/components/JobLink.js

@@ -2,12 +2,18 @@ import React from 'react';
 import { Typography } from '@mui/material';
 import ExternalLink from '../../components/ExternalLink';
 import { ebiBlastResultUrl } from '../../utils/ebiBlast';
+import { isPhmmerJobId, phmmerResultUrl } from '../../utils/phmmer';
 function JobLink({ jobId }) {
+    // read off the job id rather than the launch params, so a link rebuilt for an
+    // old cached job still points at the tool that actually ran it
+    const url = isPhmmerJobId(jobId)
+        ? phmmerResultUrl(jobId)
+        : ebiBlastResultUrl(jobId);
     return (React.createElement(Typography, null,
         "Job ",
         jobId,
         " (",
-        React.createElement(ExternalLink, { href: ebiBlastResultUrl(jobId) }, "see status"),
+        React.createElement(ExternalLink, { href: url }, "see status"),
         ")"));
 }
 export default JobLink;

package/dist/MsaViewPanel/components/LaunchProgress.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { JBrowsePluginMsaViewModel } from '../model';
+/**
+ * What a view shows while it is still building its alignment, and what it shows
+ * when that fails.
+ *
+ * Every launch that resolves something leaves its request on the model until it
+ * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
+ * there IS "no alignment yet", and the error a failed launch records is only
+ * readable here. This used to key on `blastParams` alone, which left an ortholog
+ * launch rendering an empty MSAView for the minutes its alignment takes and, on
+ * failure, forever: the error was set and nothing drew it.
+ */
+declare const LaunchProgress: ({ model, }: {
+    model: JBrowsePluginMsaViewModel;
+}) => React.JSX.Element;
+export default LaunchProgress;

package/dist/MsaViewPanel/components/LaunchProgress.js

@@ -0,0 +1,50 @@
+import React from 'react';
+import { ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
+import { Button, Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
+import JobLink from './JobLink';
+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
+ * when that fails.
+ *
+ * Every launch that resolves something leaves its request on the model until it
+ * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
+ * there IS "no alignment yet", and the error a failed launch records is only
+ * readable here. This used to key on `blastParams` alone, which left an ortholog
+ * launch rendering an empty MSAView for the minutes its alignment takes and, on
+ * failure, forever: the error was set and nothing drew it.
+ */
+const LaunchProgress = observer(function LaunchProgress2({ model, }) {
+    const { blastParams, orthologParams, progress, rid, error } = model;
+    const { classes } = useStyles();
+    const message = blastParams
+        ? 'Running EBI BLAST'
+        : orthologParams
+            ? '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(LoadingEllipses, { message: message, variant: "h5" }),
+        rid ? React.createElement(JobLink, { jobId: rid }) : null,
+        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

@@ -4,7 +4,7 @@ import { observer } from 'mobx-react';
 import { MSAView } from 'react-msaview';
 import { makeStyles } from 'tss-react/mui';
 import { ErrorBoundary } from './ErrorBoundary';
-import LoadingBLAST from './LoadingBLAST';
+import LaunchProgress from './LaunchProgress';
 const useStyles = makeStyles()({
     loadingContainer: {
         padding: 20,
@@ -12,9 +12,12 @@ const useStyles = makeStyles()({
 });
 const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     const { classes } = useStyles();
-    const { blastParams, loadingStoredData } = model;
+    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);
     return (React.createElement(ErrorBoundary, null,
-        React.createElement("div", null, blastParams ? (React.createElement(LoadingBLAST, { model: model })) : loadingStoredData ? (React.createElement("div", { className: classes.loadingContainer },
+        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 })))));
 });
 export default MsaViewPanel;

package/dist/MsaViewPanel/components/MsaViewPanel.test.d.ts

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

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

@@ -0,0 +1,87 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import MsaViewPanel from './MsaViewPanel';
+// react-msaview's MSAView is the "nothing is launching" branch and wants a real
+// MST model; a marker is enough to say the panel reached it
+vi.mock('react-msaview', () => ({
+    MSAView: () => React.createElement("div", null, "the alignment"),
+}));
+function panel(model) {
+    return render(React.createElement(MsaViewPanel, { model: model }));
+}
+afterEach(() => {
+    cleanup();
+});
+test('an alignment with no pending launch draws itself', () => {
+    panel({ progress: '' });
+    expect(screen.getByText('the alignment')).toBeTruthy();
+});
+test('a running BLAST shows its progress, not an empty alignment', () => {
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: 'Submitting query',
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText(/Running EBI BLAST/)).toBeTruthy();
+    expect(screen.getByText('Submitting query')).toBeTruthy();
+});
+// the bug this file was written for: an ortholog launch sets orthologParams
+// rather than blastParams, and the panel keyed on blastParams alone -- so it
+// rendered an empty MSAView for the minutes the alignment takes, and drew
+// nothing at all when the launch failed
+test('a running ortholog launch shows its progress', () => {
+    panel({
+        orthologParams: { taxId: 9606 },
+        progress: 'Resolving orthologs',
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText(/Building ortholog alignment/)).toBeTruthy();
+    expect(screen.getByText('Resolving orthologs')).toBeTruthy();
+});
+test('a failed ortholog launch shows why', () => {
+    panel({
+        orthologParams: { taxId: 9606 },
+        progress: '',
+        error: new Error('Only 1 ortholog(s) found for this gene'),
+    });
+    expect(screen.getByText(/Only 1 ortholog\(s\) found/)).toBeTruthy();
+});
+test('a failed init shows why', () => {
+    panel({
+        init: { msaName: 'ENST00000288602' },
+        progress: '',
+        error: new Error('No alignment named ENST00000288602 in msa.fa.gz'),
+    });
+    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' },
+        progress: 'Re-checking BLAST status in... 7',
+        rid: 'ncbiblast-R20260826-123456-0001-abc',
+    });
+    const link = screen.getByRole('link');
+    expect(link.getAttribute('href')).toContain('jobId=ncbiblast-R20260826-123456-0001-abc');
+});

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -1,8 +1,10 @@
 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<{
-    treeMetadata: string;
     msa: string;
     tree: string;
+    treeMetadata: string;
 }>;