jbrowse-plugin-msaview 3.4.1 → 3.5.0

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -8,7 +8,7 @@ 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;
@@ -73,16 +73,20 @@ function sameData(a, b) {
  * 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.
+ * 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, lastStoredData } = self;
+    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;
@@ -117,7 +121,7 @@ export function storeDataToIndexedDB(self) {
  * until a new request replaces them.
  */
 export function launchOrthologsIfNeeded(self) {
-    if (self.orthologParams) {
+    if (self.orthologParams && !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Resolving orthologs',
@@ -128,8 +132,17 @@ export function launchOrthologsIfNeeded(self) {
         });
     }
 }
+/**
+ * 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) {
+    if (self.blastParams && !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Submitting query',
@@ -167,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);
@@ -204,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);
@@ -238,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 [];
     }
@@ -255,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

@@ -29,16 +29,25 @@ 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("div", { className: classes.progressRow },

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' },
@@ -58,7 +68,7 @@ test('a failed init shows why', () => {
     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', () => {
+test('a running launch offers a way out', () => {
     const cancelLaunch = vi.fn();
     panel({
         blastParams: { proteinSequence: 'MKV' },
@@ -67,14 +77,25 @@ test('a running launch offers a way out, and a failed one does not', () => {
     });
     screen.getByRole('button', { name: 'Cancel' }).click();
     expect(cancelLaunch).toHaveBeenCalled();
-    cleanup();
+});
+// 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({

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -1,5 +1,13 @@
 import type { JBrowsePluginMsaViewModel } from './model';
 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;

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -1,114 +1,99 @@
-import { makeId, strip } from '../LaunchMsaView/components/util';
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
-import { queryEbiBlast } from '../utils/ebiBlast';
-import { launchMSA, launchTree } from '../utils/msa';
-import { buildPhmmerMsa, buildRowMetadata } from '../utils/msaRows';
-import { queryPhmmer } from '../utils/phmmer';
+import { searchBackends } from '../utils/homologSearch';
+import { launchMSA } from '../utils/msa';
+import { buildSearchMsa } from '../utils/msaRows';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
-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, 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,
-            blastDatabase: params.blastDatabase,
-            msaAlgorithm: params.msaAlgorithm,
-            onProgress,
-            onRid,
-            signal,
-        });
-    const treeMetadataJson = JSON.stringify(treeMetadata);
-    await saveBlastResult({
-        proteinSequence: cleanedSeq,
-        blastDatabase: params.blastDatabase,
-        msaAlgorithm: params.msaAlgorithm,
-        searchProgram: params.searchProgram,
-        msa,
-        tree,
-        treeMetadata: treeMetadataJson,
-        rid,
-        geneId: selectedTranscript?.get('parentId'),
-        transcriptId: selectedTranscript?.id(),
-        transcriptName: selectedTranscript?.get('name') ?? selectedTranscript?.get('id'),
-        geneName: selectedTranscript?.get('gene_name') ??
-            selectedTranscript?.get('parentId'),
-    });
-    return { msa, tree, treeMetadata: treeMetadataJson };
+import { resolveUniProtEntry } from '../utils/unirefHomologs';
+import { transcriptFields, transcriptName } from './util';
+function asString(val) {
+    return typeof val === 'string' ? val : undefined;
 }
 /**
- * BLAST returns each hit already aligned to the query, but pairwise and one hit
- * at a time, so the alignments are stripped back off and every hit is realigned
- * together by a dedicated aligner.
+ * The query sequence, and what its row is called. The dialog hands over the
+ * translated transcript and the row stays `QUERY`; a spec naming a UniProt
+ * accession has the sequence fetched and the row named after the entry
+ * (`P53_HUMAN_query`), since a search of swissprot returns the entry itself
+ * as a hit and two rows called the same thing collapse into one.
  */
-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
-        .map(h => h.description[0]?.taxid)
-        .filter((t) => t !== undefined));
-    const treeMetadata = {};
-    const sequences = hits.map(h => {
-        const desc = h.description[0] ?? {
-            accession: 'unknown',
-            id: 'unknown',
-            sciname: 'unknown',
+async function resolveQuery(self, scope) {
+    const params = self.blastParams;
+    if (params.proteinSequence) {
+        return {
+            sequence: cleanProteinSequence(params.proteinSequence),
+            name: self.querySeqName,
         };
-        const rowName = makeId(desc, taxonomyInfo);
-        treeMetadata[rowName] = buildRowMetadata(desc, taxonomyInfo);
-        return `>${rowName}\n${strip(h.hsps[0]?.hseq ?? '')}`;
-    });
-    const result = await launchMSA({
-        algorithm: msaAlgorithm,
-        sequence: [`>QUERY\n${query}`, ...sequences].join('\n'),
-        onProgress,
-        signal,
-    });
-    return { ...result, treeMetadata, rid };
+    }
+    if (params.accession) {
+        scope.onProgress(`Fetching ${params.accession} from UniProt...`);
+        const entry = await resolveUniProtEntry([params.accession], 0, scope.signal);
+        if (!entry) {
+            throw new Error(`UniProt has no entry ${params.accession}`);
+        }
+        const name = `${entry.id}_query`;
+        scope.act(() => {
+            self.setQuerySeqName(name);
+        });
+        return { sequence: entry.sequence, name };
+    }
+    throw new Error('No query: a search needs a proteinSequence, a UniProt accession, or a connectedTranscript to translate');
 }
 /**
- * phmmer aligns every hit to a profile of the query as it searches, so its own
- * output is the MSA and there is no realignment step — the hits keep the
- * placement HMMER gave them, and the query row is derived from the alignment's
- * 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.
+ * 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.
  */
-async function runPhmmer({ query, database, onProgress, onRid, signal, }) {
-    const { rows, queryRow, rid } = await queryPhmmer({
+export async function doLaunchBlast({ self, scope, }) {
+    const params = self.blastParams;
+    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
+    const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
+    const { onProgress, onRid, signal } = scope;
+    const { hits, queryRow, rid } = await searchBackends[searchProgram]({
         query,
-        database,
+        database: params.blastDatabase,
+        maxHits,
         onProgress,
         onRid,
         signal,
     });
+    if (hits.length === 0) {
+        throw new Error('No hits found');
+    }
     onProgress('Fetching species taxonomy info...');
-    const taxonomyInfo = await fetchTaxonomyInfo(rows.map(r => r.taxid).filter((t) => t !== undefined));
-    const { msa, treeMetadata } = buildPhmmerMsa({
-        rows,
+    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined));
+    const { msa: fasta, treeMetadata } = buildSearchMsa({
+        hits,
+        query,
         queryRow,
         taxonomyInfo,
+        querySeqName,
     });
-    return {
+    const { msa, tree } = queryRow
+        ? { msa: fasta, tree: '' }
+        : await launchMSA({
+            algorithm: params.msaAlgorithm ?? 'browser',
+            sequence: fasta,
+            onProgress,
+            signal,
+        });
+    const transcript = transcriptFields(selectedTranscript);
+    const treeMetadataJson = JSON.stringify(treeMetadata);
+    await saveBlastResult({
+        proteinSequence: query,
+        blastDatabase: params.blastDatabase,
+        msaAlgorithm: params.msaAlgorithm,
+        searchProgram: params.searchProgram,
         msa,
-        tree: await launchTree({ alignment: msa, onProgress, signal }),
-        treeMetadata,
-        rid,
-    };
+        tree,
+        treeMetadata: treeMetadataJson,
+        rid: rid ?? '',
+        geneId: asString(transcript.parentId),
+        transcriptId: asString(transcript.uniqueId),
+        transcriptName: transcriptName(selectedTranscript),
+        geneName: asString(transcript.gene_name) ?? asString(transcript.parentId),
+    });
+    return { msa, tree, treeMetadata: treeMetadataJson };
 }

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

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

package/dist/MsaViewPanel/doLaunchBlast.test.js

@@ -0,0 +1,158 @@
+import { beforeEach, expect, test, vi } from 'vitest';
+import { saveBlastResult } from '../utils/blastCache';
+import { searchBackends } from '../utils/homologSearch';
+import { launchMSA } from '../utils/msa';
+import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
+import { resolveUniProtEntry } from '../utils/unirefHomologs';
+import { doLaunchBlast } from './doLaunchBlast';
+// Every network call is mocked: what is under test is how the launch turns a
+// request into a search and the search's answer into rows -- which backend it
+// asks, where the query comes from, and whether an aligner runs.
+vi.mock('../utils/homologSearch', () => ({
+    searchBackends: { blastp: vi.fn(), phmmer: vi.fn() },
+}));
+vi.mock('../utils/msa', () => ({ launchMSA: vi.fn() }));
+vi.mock('../utils/taxonomyNames', () => ({ fetchTaxonomyInfo: vi.fn() }));
+vi.mock('../utils/blastCache', () => ({ saveBlastResult: vi.fn() }));
+vi.mock('../utils/unirefHomologs', () => ({ resolveUniProtEntry: vi.fn() }));
+const blastp = vi.mocked(searchBackends.blastp);
+const phmmer = vi.mocked(searchBackends.phmmer);
+const mockLaunchMSA = vi.mocked(launchMSA);
+const setQuerySeqName = vi.fn();
+const HIT = { accession: 'P1', id: 'P1_MOUSE', sciname: 'Mus musculus' };
+function makeModel(blastParams) {
+    return {
+        blastParams,
+        querySeqName: 'QUERY',
+        setQuerySeqName,
+    };
+}
+function launch(self) {
+    return doLaunchBlast({
+        self,
+        scope: {
+            signal: new AbortController().signal,
+            act: fn => {
+                fn();
+            },
+            onProgress: () => { },
+            onRid: () => { },
+        },
+    });
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(fetchTaxonomyInfo).mockResolvedValue(new Map());
+    vi.mocked(saveBlastResult).mockResolvedValue(undefined);
+});
+test('bare hits go to the chosen aligner, with the query first', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: 'tree' });
+    const result = await launch(makeModel({
+        searchProgram: 'blastp',
+        blastDatabase: 'uniprotkb_swissprot',
+        msaAlgorithm: 'clustalo',
+        maxHits: 20,
+        proteinSequence: 'MKWVTF*',
+    }));
+    expect(blastp).toHaveBeenCalledWith(expect.objectContaining({
+        query: 'MKWVTF',
+        database: 'uniprotkb_swissprot',
+        maxHits: 20,
+    }));
+    expect(mockLaunchMSA).toHaveBeenCalledWith(expect.objectContaining({
+        algorithm: 'clustalo',
+        sequence: '>QUERY\nMKWVTF\n>P1-Mus_musculus\nMKWV',
+    }));
+    expect(result.msa).toBe('aligned');
+    expect(result.tree).toBe('tree');
+});
+test('an aligned result skips the aligner and leaves the tree to the browser', async () => {
+    phmmer.mockResolvedValue({
+        rid: 'job',
+        queryRow: 'MKWV-TF',
+        hits: [{ ...HIT, sequence: 'MKWVSTF' }],
+    });
+    const result = await launch(makeModel({
+        searchProgram: 'phmmer',
+        blastDatabase: 'rp15',
+        proteinSequence: 'MKWVTF',
+    }));
+    expect(mockLaunchMSA).not.toHaveBeenCalled();
+    expect(result.msa).toBe('>QUERY\nMKWV-TF\n>P1-Mus_musculus\nMKWVSTF');
+    expect(result.tree).toBe('');
+});
+test('a UniProt accession supplies the query and names its row', async () => {
+    vi.mocked(resolveUniProtEntry).mockResolvedValue({
+        accession: 'P04637',
+        id: 'P53_HUMAN',
+        reviewed: true,
+        taxId: 9606,
+        scientificName: 'Homo sapiens',
+        sequence: 'MEEPQ',
+    });
+    phmmer.mockResolvedValue({
+        queryRow: 'MEEPQ',
+        hits: [{ ...HIT, sequence: 'MEEPQ' }],
+    });
+    const result = await launch(makeModel({
+        searchProgram: 'phmmer',
+        blastDatabase: 'swissprot',
+        accession: 'P04637',
+    }));
+    expect(resolveUniProtEntry).toHaveBeenCalledWith(['P04637'], 0, expect.any(AbortSignal));
+    expect(setQuerySeqName).toHaveBeenCalledWith('P53_HUMAN_query');
+    expect(result.msa.split('\n')[0]).toBe('>P53_HUMAN_query');
+});
+test('a request with no query at all is refused before any search runs', async () => {
+    await expect(launch(makeModel({ searchProgram: 'phmmer', blastDatabase: 'swissprot' }))).rejects.toThrow(/connectedTranscript/);
+    expect(phmmer).not.toHaveBeenCalled();
+});
+// blastParams is a frozen snapshot property, so the Feature the dialog put in
+// it comes back from a session reload as the plain JSON it serialized to. The
+// launch used to call .get() on that, minutes after the EBI job the reload
+// resubmitted had come back, and threw where nothing was catching.
+test('a transcript restored from a session snapshot still labels the cache row', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: 'tree' });
+    await launch(makeModel({
+        searchProgram: 'blastp',
+        blastDatabase: 'uniprotkb_swissprot',
+        msaAlgorithm: 'clustalo',
+        proteinSequence: 'MKWV',
+        selectedTranscript: {
+            uniqueId: 'NM_000546.6',
+            name: 'TP53-201',
+            parentId: 'TP53',
+            gene_name: 'TP53',
+        },
+    }));
+    expect(saveBlastResult).toHaveBeenCalledWith(expect.objectContaining({
+        geneId: 'TP53',
+        transcriptId: 'NM_000546.6',
+        transcriptName: 'TP53-201',
+        geneName: 'TP53',
+    }));
+});
+test('a live Feature handed over in the same session labels it the same way', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: 'tree' });
+    const json = {
+        uniqueId: 'NM_000546.6',
+        name: 'TP53-201',
+        parentId: 'TP53',
+    };
+    await launch(makeModel({
+        searchProgram: 'blastp',
+        blastDatabase: 'uniprotkb_swissprot',
+        msaAlgorithm: 'clustalo',
+        proteinSequence: 'MKWV',
+        selectedTranscript: { toJSON: () => json },
+    }));
+    expect(saveBlastResult).toHaveBeenCalledWith(expect.objectContaining({
+        geneId: 'TP53',
+        transcriptId: 'NM_000546.6',
+        transcriptName: 'TP53-201',
+        geneName: 'TP53',
+    }));
+});