jbrowse-plugin-msaview 3.5.0 → 3.7.0

package/dist/MsaViewPanel/model.test.js

@@ -61,6 +61,39 @@ describe('a failed launch', () => {
         expect(model.blastParams).toEqual(BLAST_PARAMS);
         expect(doLaunchBlast).toHaveBeenCalledTimes(2);
     });
+    // the params used to be cleared on success to mark the request done, which
+    // threw away the only durable statement of what the view is: a stored
+    // alignment expires after 7 days and there was nothing left to run again
+    test('a successful launch keeps its request and is not run twice', async () => {
+        vi.mocked(doLaunchBlast).mockResolvedValue({
+            msa: '>a\nMK\n>b\nMK',
+            tree: '(a,b);',
+            treeMetadata: '{}',
+        });
+        const model = view();
+        model.setBlastParams({ ...BLAST_PARAMS });
+        await new Promise(res => setTimeout(res, 0));
+        expect(model.blastParams).toEqual(BLAST_PARAMS);
+        expect(model.launchCompleted).toBe(true);
+        expect(doLaunchBlast).toHaveBeenCalledTimes(1);
+        vi.mocked(doLaunchBlast).mockReturnValue(new Promise(() => { }));
+        model.setError(new Error('alignment is no longer in browser storage'));
+        model.retryLaunch();
+        expect(model.error).toBeUndefined();
+        expect(model.launchCompleted).toBe(false);
+        expect(doLaunchBlast).toHaveBeenCalledTimes(2);
+    });
+    // a session reopens with the request still on it, so the mark is what stops
+    // the whole search running again unasked
+    test('a restored session does not rerun a request it already ran', () => {
+        stateModelFactory().create({
+            type: 'MsaView',
+            id: 'msaview2',
+            blastParams: { ...BLAST_PARAMS },
+            launchCompleted: true,
+        });
+        expect(doLaunchBlast).not.toHaveBeenCalled();
+    });
     test('dismisses by dropping it', () => {
         const model = view();
         model.setBlastParams({ ...BLAST_PARAMS });
@@ -70,6 +103,39 @@ describe('a failed launch', () => {
         expect(model.error).toBeUndefined();
     });
 });
+// react-msaview drops a snapshot document past 50kb and reports it through
+// `unshareableData`, which the header renders as "Not in the link". An indexed
+// view's alignment IS in the link -- its init names the block and processInit
+// refetches it -- so that view answers the question itself.
+describe('what the snapshot cannot carry', () => {
+    const big = `>a\n${'M'.repeat(60_000)}`;
+    test('an indexed view says the host brings its alignment back', () => {
+        const model = view();
+        model.setInit({
+            msaIndexedLocation: { uri: 'msa.fa.gz' },
+            msaName: 'ENST1',
+        });
+        model.setMSA(big);
+        expect(model.hostRestoresData).toBe(true);
+        expect(model.unshareableData).toEqual([]);
+    });
+    // the base getter reads a volatile a host flips to say it brings the data
+    // back by its own means; overriding without it threw that switch away
+    test('a host that says it carries the data is still believed', () => {
+        const model = view();
+        model.setMSA(big);
+        expect(model.unshareableData).not.toEqual([]);
+        model.setHostCarriesData(true);
+        expect(model.hostRestoresData).toBe(true);
+        expect(model.unshareableData).toEqual([]);
+    });
+    test('a pasted alignment is reported, because a link really does lose it', () => {
+        const model = view();
+        model.setMSA(big);
+        expect(model.hostRestoresData).toBe(false);
+        expect(model.unshareableData.map(d => d.what)).toEqual(['alignment']);
+    });
+});
 // react-msaview's reset keeps only what is on its own preservedOnReset list,
 // and a downstream property is never on it; its volatiles survive instead,
 // which is the direction that carries the last file's state into the next one

package/dist/MsaViewPanel/msaDataStore.d.ts

@@ -3,13 +3,15 @@ export interface MsaDataPayload {
     msa?: string;
     tree?: string;
     treeMetadata?: string;
+    gff?: string;
 }
 export declare function generateDataStoreId(): string;
 export declare function storeMsaData(id: string, data: MsaDataPayload): Promise<boolean>;
 export declare function retrieveMsaData(id: string): Promise<{
-    msa: string | undefined;
-    tree: string | undefined;
-    treeMetadata: string | undefined;
+    msa?: string;
+    tree?: string;
+    treeMetadata?: string;
+    gff?: string;
 } | undefined>;
 /** drop one view's row, for a reset that just orphaned it */
 export declare function deleteMsaData(id: string): Promise<void>;

package/dist/MsaViewPanel/msaDataStore.js

@@ -14,13 +14,7 @@ export function generateDataStoreId() {
 export async function storeMsaData(id, data) {
     try {
         const db = await getDB();
-        const storedData = {
-            id,
-            msa: data.msa,
-            tree: data.tree,
-            treeMetadata: data.treeMetadata,
-            timestamp: Date.now(),
-        };
+        const storedData = { ...data, id, timestamp: Date.now() };
         await db.put(STORE_NAME, storedData);
         return true;
     }
@@ -45,11 +39,8 @@ export async function retrieveMsaData(id) {
         catch (e) {
             console.warn('Failed to refresh MSA data timestamp:', e);
         }
-        return {
-            msa: result.msa,
-            tree: result.tree,
-            treeMetadata: result.treeMetadata,
-        };
+        const { id: _id, timestamp: _timestamp, ...payload } = result;
+        return payload;
     }
     catch (e) {
         console.warn('Failed to retrieve MSA data:', e);

package/dist/MsaViewPanel/msaDataStore.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, expect, test, vi } from 'vitest';
-import { retrieveMsaData } from './msaDataStore';
+import { retrieveMsaData, storeMsaData } from './msaDataStore';
 // An in-memory stand-in for the one object store this module opens, with a
 // switch for the write half so a browser that refuses writes can be played back.
 const { rows, state } = vi.hoisted(() => ({
@@ -42,3 +42,10 @@ test('a refresh that fails still hands back the data it read', async () => {
     state.putFails = true;
     expect((await retrieveMsaData('msa-1'))?.msa).toBe('>a\nMK');
 });
+test('every document a view keeps comes back, and nothing else', async () => {
+    await storeMsaData('msa-1', { msa: '>a\nMK', gff: 'a\t.\tdomain\t1\t2' });
+    expect(await retrieveMsaData('msa-1')).toEqual({
+        msa: '>a\nMK',
+        gff: 'a\t.\tdomain\t1\t2',
+    });
+});

package/dist/MsaViewPanel/observeProteinHighlights.test.js

@@ -19,7 +19,7 @@ function makeModel({ highlightColumns, querySeqOffset = 0, } = {}) {
     const model = {
         querySeqName: 'query',
         querySeqOffset,
-        rows: [['query', 'MKVLTAEEK']],
+        rowMap: new Map([['query', 'MKVLTAEEK']]),
         connectedViewId: CONNECTED,
         // g2p is indexed by genome coord; identity keeps the arithmetic out of the way
         transcriptToMsaMap: {
@@ -213,11 +213,11 @@ describe('scope and redundant writes', () => {
         run();
         expect(calls).toEqual([]);
     });
-    // seqPosToGlobalCol answers 0 for a row name it does not know, so without a
-    // guard a structure hover would light column 0 of whatever row is first
     test('a query row this alignment does not have contributes no column', () => {
         const { model, calls } = makeModel();
-        Object.assign(model, { rows: [['some_other_row', 'MKVLTAEEK']] });
+        Object.assign(model, {
+            rowMap: new Map([['some_other_row', 'MKVLTAEEK']]),
+        });
         const run = observeProteinHighlights(model);
         session({ hover: [{ start: 10, end: 12 }] });
         run();

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

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

package/dist/MsaViewPanel/regionSnapshot.test.js

@@ -0,0 +1,29 @@
+import { expect, test, vi } from 'vitest';
+import stateModelFactory from './model';
+vi.mock('@jbrowse/core/util', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getSession: () => ({ views: [], hovered: undefined }),
+}));
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(async () => { }),
+    deleteMsaData: vi.fn(async () => { }),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(async () => true),
+}));
+const MSA = `>Human\n${'MEEPQSDPSV'.repeat(20)}\n>Mouse\n${'MEE-QSDPSV'.repeat(20)}`;
+test('a spec region waits for the view to have a width, zooms, and is dropped', () => {
+    const region = { row: 'Human', start: 150, end: 160 };
+    const model = stateModelFactory().create({
+        type: 'MsaView',
+        id: 'msaview1',
+        data: { msa: MSA },
+        region,
+        gffFilehandle: { uri: 'http://example.com/a.gff' },
+    });
+    expect(model.region).toEqual(region);
+    expect(model.gffFilehandle).toMatchObject({ locationType: 'UriLocation' });
+    model.setWidth(800);
+    expect(model.region).toBeUndefined();
+    expect(model.scrollX).toBeLessThan(0);
+});

package/dist/MsaViewPanel/resolveConnectedTranscript.d.ts

@@ -1,9 +1,46 @@
 import type { JBrowsePluginMsaViewModel } from './model';
+interface Region {
+    assemblyName: string;
+    refName: string;
+    start: number;
+    end: number;
+}
+interface GenomeView {
+    tracks: {
+        type: string;
+    }[];
+    displayedRegions: Region[];
+    dynamicBlocks?: {
+        contentBlocks?: Region[];
+    };
+}
+/**
+ * The part of the genome on screen, then everything the view can scroll to.
+ * `displayedRegions` is usually whole chromosomes -- navigating to a locus
+ * displays its parent region -- so it is the fallback, not the first ask.
+ */
+export declare function searchWindows(view: GenomeView): {
+    assemblyName: string;
+    refName: string;
+    start: number;
+    end: number;
+}[][];
+/**
+ * Gene models live on feature tracks. Asking an alignments, variant or
+ * quantitative track for a chromosome's worth of features to look for a
+ * transcript among them is the slowest possible way to find nothing.
+ */
+export declare function transcriptTracks<T extends {
+    type: string;
+}>(tracks: T[]): T[];
 /**
  * Resolve `connectedTranscript` into `connectedFeature` once the connected
- * genome view has its assembly, regions and tracks, then hand the translation
- * to whichever launch is waiting for a query. Left in place on failure so the
- * error stays attributable; the autorun's tracked reads are the view's
- * readiness, so nothing refires until that changes.
+ * genome view has its assembly and tracks, then hand the translation to
+ * whichever launch is waiting for a query.
+ *
+ * The autorun re-fires on the view's readiness (a track opened after a miss)
+ * and on the request itself, which is what `retryLaunch` re-states. The lookup
+ * runs untracked, so scrolling the genome view is not a reason to look again.
  */
 export declare function resolveConnectedTranscriptIfNeeded(self: JBrowsePluginMsaViewModel): void;
+export {};

package/dist/MsaViewPanel/resolveConnectedTranscript.js

@@ -1,22 +1,10 @@
 import { getConf } from '@jbrowse/core/configuration';
 import { getSession } from '@jbrowse/core/util';
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { transaction, untracked } from 'mobx';
 import { getProteinSequenceFromFeature } from '../LaunchMsaView/components/calculateProteinSequence';
 import { fetchSeq } from '../LaunchMsaView/components/fetchSeq';
 import { getTranscriptFeatures } from '../LaunchMsaView/util';
-// The short form of a connected launch. A spec that says
-//
-//   {"type":"MsaView","connectedViewId":"lgv1","connectedTranscript":"NM_000546.6", ...}
-//
-// gets its `connectedFeature` -- the exon model every genome<->column mapping
-// runs through -- looked up here, from the gene tracks the connected genome
-// view has open, and its query row translated from that transcript. Before
-// this the spec had to carry the transcript's CDS list itself, ~1.5kB of
-// coordinates a person cannot type and a tutorial cannot show.
-//
-// jbrowse-plugin-protein3d does the same for its `transcriptId` shorthand,
-// against a `connectedView` spec of its own; here the genome view already
-// exists (the spec pinned its id), so its tracks and regions are read off the
-// live model instead.
 function stripVersion(id) {
     return id.replace(/\.\d+$/, '');
 }
@@ -29,26 +17,51 @@ function transcriptMatches(transcript, id) {
         transcript.id(),
     ].some(c => typeof c === 'string' && (c === id || stripVersion(c) === target));
 }
+function plainRegions(regions) {
+    return regions.map(r => ({
+        assemblyName: r.assemblyName,
+        refName: r.refName,
+        start: Math.floor(r.start),
+        end: Math.ceil(r.end),
+    }));
+}
+/**
+ * The part of the genome on screen, then everything the view can scroll to.
+ * `displayedRegions` is usually whole chromosomes -- navigating to a locus
+ * displays its parent region -- so it is the fallback, not the first ask.
+ */
+export function searchWindows(view) {
+    const visible = plainRegions(view.dynamicBlocks?.contentBlocks ?? []);
+    const displayed = plainRegions(view.displayedRegions);
+    return visible.length > 0 ? [visible, displayed] : [displayed];
+}
+/**
+ * Gene models live on feature tracks. Asking an alignments, variant or
+ * quantitative track for a chromosome's worth of features to look for a
+ * transcript among them is the slowest possible way to find nothing.
+ */
+export function transcriptTracks(tracks) {
+    return tracks.filter(t => t.type === 'FeatureTrack');
+}
 async function findTranscript(self, transcriptId) {
     const view = self.connectedView;
     const session = getSession(self);
     const sessionId = 'msaview-connectedTranscript';
-    const regions = view.displayedRegions.map(r => ({
-        assemblyName: r.assemblyName,
-        refName: r.refName,
-        start: r.start,
-        end: r.end,
-    }));
-    for (const track of view.tracks) {
-        const feats = (await session.rpcManager.call(sessionId, 'CoreGetFeatures', {
-            adapterConfig: getConf(track, 'adapter'),
-            sessionId,
-            regions,
-        }));
-        for (const feat of feats) {
-            const hit = getTranscriptFeatures(feat).find(t => transcriptMatches(t, transcriptId));
-            if (hit) {
-                return hit;
+    const tracks = transcriptTracks(view.tracks);
+    for (const regions of searchWindows(view)) {
+        for (const track of tracks) {
+            // a named object keeps sessionId, which v4 hosts read from the args
+            const args = {
+                adapterConfig: getConf(track, 'adapter'),
+                sessionId,
+                regions,
+            };
+            const feats = await session.rpcManager.call(sessionId, 'CoreGetFeatures', args);
+            for (const feat of feats) {
+                const hit = getTranscriptFeatures(feat).find(t => transcriptMatches(t, transcriptId));
+                if (hit) {
+                    return hit;
+                }
             }
         }
     }
@@ -57,46 +70,43 @@ async function findTranscript(self, transcriptId) {
 async function translate(self, transcript) {
     const { start, end, refName } = transcript.toJSON();
     const assemblyName = self.connectedView.assemblyNames[0];
-    const seq = await fetchSeq({
+    const { seq, assemblyGeneticCodeId } = await fetchSeq({
         start,
         end,
         refName,
         assemblyName,
         session: getSession(self),
     });
-    return getProteinSequenceFromFeature({ seq, feature: transcript });
+    return getProteinSequenceFromFeature({
+        seq,
+        feature: transcript,
+        assemblyGeneticCodeId,
+    });
 }
-/**
- * Resolve `connectedTranscript` into `connectedFeature` once the connected
- * genome view has its assembly, regions and tracks, then hand the translation
- * to whichever launch is waiting for a query. Left in place on failure so the
- * error stays attributable; the autorun's tracked reads are the view's
- * readiness, so nothing refires until that changes.
- */
-export function resolveConnectedTranscriptIfNeeded(self) {
-    const { connectedTranscript, connectedFeature, connectedView } = self;
-    if (!connectedTranscript ||
-        connectedFeature ||
-        !connectedView?.initialized ||
-        connectedView.tracks.length === 0) {
-        return;
-    }
-    const trackCount = connectedView.tracks.length;
-    void (async () => {
-        try {
-            self.setProgress(`Looking up ${connectedTranscript} in the genome view...`);
-            const transcript = await findTranscript(self, connectedTranscript);
-            if (!transcript) {
-                throw new Error(`Transcript "${connectedTranscript}" was not found in the ${trackCount} track(s) open in the connected genome view. Open the gene track that carries it, and make sure the view is on its locus.`);
-            }
-            const proteinSequence = await translate(self, transcript);
-            if (!proteinSequence) {
-                throw new Error(`Transcript "${connectedTranscript}" has no CDS to translate`);
-            }
-            // toJSON, not the Feature: the params are frozen snapshot properties, so
-            // an instance in one is gone the moment the session reloads
-            const transcriptJson = transcript.toJSON();
-            const { blastParams, orthologParams } = self;
+/** the latest lookup per view; an older one finishing late writes nothing */
+const latestLookup = new WeakMap();
+async function lookUp({ self, transcriptId, blastParams, orthologParams, isCurrent, }) {
+    const trackCount = transcriptTracks(self.connectedView.tracks).length;
+    try {
+        self.setProgress(`Looking up ${transcriptId} in the genome view...`);
+        const transcript = await findTranscript(self, transcriptId);
+        if (!transcript) {
+            throw new Error(`Transcript "${transcriptId}" was not found in the ${trackCount} feature track(s) open in the connected genome view. Open the gene track that carries it, and make sure the view is on its locus.`);
+        }
+        const proteinSequence = await translate(self, transcript);
+        if (!proteinSequence) {
+            throw new Error(`Transcript "${transcriptId}" has no CDS to translate`);
+        }
+        if (!isCurrent()) {
+            return;
+        }
+        // toJSON, not the Feature: the params are frozen snapshot properties, so
+        // an instance in one is gone the moment the session reloads
+        const transcriptJson = transcript.toJSON();
+        // one transaction, so the launchers wake once, on a request that already
+        // carries its query
+        transaction(() => {
+            self.setProgress('');
             if (blastParams && !blastParams.proteinSequence) {
                 self.setBlastParams({
                     ...blastParams,
@@ -111,12 +121,43 @@ export function resolveConnectedTranscriptIfNeeded(self) {
                     proteinSequence,
                 });
             }
-            // last, because the launchers wake on it
             self.setConnectedFeature(transcriptJson);
-        }
-        catch (e) {
-            console.error(e);
+        });
+    }
+    catch (e) {
+        console.error(e);
+        if (isCurrent()) {
+            self.setProgress('');
             self.setError(e);
         }
-    })();
+    }
+}
+/**
+ * Resolve `connectedTranscript` into `connectedFeature` once the connected
+ * genome view has its assembly and tracks, then hand the translation to
+ * whichever launch is waiting for a query.
+ *
+ * The autorun re-fires on the view's readiness (a track opened after a miss)
+ * and on the request itself, which is what `retryLaunch` re-states. The lookup
+ * runs untracked, so scrolling the genome view is not a reason to look again.
+ */
+export function resolveConnectedTranscriptIfNeeded(self) {
+    const { connectedTranscript, connectedFeature, connectedView, blastParams, orthologParams, } = self;
+    if (!connectedTranscript ||
+        connectedFeature ||
+        !connectedView?.initialized ||
+        connectedView.tracks.length === 0) {
+        return;
+    }
+    const lookup = (latestLookup.get(self) ?? 0) + 1;
+    latestLookup.set(self, lookup);
+    untracked(() => {
+        void lookUp({
+            self,
+            transcriptId: connectedTranscript,
+            blastParams,
+            orthologParams,
+            isCurrent: () => isAlive(self) && latestLookup.get(self) === lookup,
+        });
+    });
 }

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

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

package/dist/MsaViewPanel/resolveConnectedTranscript.test.js

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import stateModelFactory from './model';
+const rpcCall = vi.fn();
+const lgv = {
+    id: 'lgv1',
+    initialized: true,
+    assemblyNames: ['hg38'],
+    tracks: [],
+    displayedRegions: [
+        { assemblyName: 'hg38', refName: 'chr17', start: 0, end: 83_257_441 },
+    ],
+    dynamicBlocks: {
+        contentBlocks: [],
+    },
+};
+vi.mock('@jbrowse/core/util', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getSession: () => ({
+        views: [lgv],
+        hovered: undefined,
+        rpcManager: { call: rpcCall },
+    }),
+}));
+vi.mock('@jbrowse/core/configuration', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getConf: (track) => track.adapter,
+}));
+vi.mock('../LaunchMsaView/components/fetchSeq', () => ({
+    fetchSeq: vi.fn(async () => ({ seq: 'ATGAAAGTG' })),
+}));
+vi.mock('../LaunchMsaView/components/calculateProteinSequence', () => ({
+    getProteinSequenceFromFeature: vi.fn(() => 'MKV'),
+}));
+vi.mock('./doLaunchBlast', () => ({
+    doLaunchBlast: vi.fn(() => new Promise(() => { })),
+}));
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(async () => { }),
+    deleteMsaData: vi.fn(async () => { }),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(),
+}));
+function transcript(id) {
+    const json = { uniqueId: id, id, refName: 'chr17', start: 0, end: 9 };
+    return {
+        id: () => id,
+        get: (key) => (key === 'id' || key === 'name' ? id : undefined),
+        toJSON: () => json,
+    };
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+function connectedView() {
+    return stateModelFactory().create({
+        type: 'MsaView',
+        id: 'msa1',
+        connectedViewId: 'lgv1',
+        connectedTranscript: 'NM_000546.6',
+        blastParams: {
+            searchProgram: 'blastp',
+            blastDatabase: 'uniprotkb_swissprot',
+            msaAlgorithm: 'clustalo',
+        },
+    });
+}
+beforeEach(() => {
+    rpcCall.mockReset();
+    lgv.tracks = [{ type: 'FeatureTrack', adapter: 'genes' }];
+    lgv.dynamicBlocks.contentBlocks = [];
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+});
+describe('a lookup that misses', () => {
+    test('reports the miss without leaving its progress up', async () => {
+        rpcCall.mockResolvedValue([]);
+        const model = connectedView();
+        await settle();
+        expect(model.error).toBeInstanceOf(Error);
+        expect(model.progress).toBe('');
+    });
+    test('Retry looks again', async () => {
+        rpcCall.mockResolvedValue([]);
+        const model = connectedView();
+        await settle();
+        const calls = rpcCall.mock.calls.length;
+        rpcCall.mockResolvedValue([transcript('NM_000546.6')]);
+        model.retryLaunch();
+        await settle();
+        expect(rpcCall.mock.calls.length).toBeGreaterThan(calls);
+        expect(model.connectedFeature).toMatchObject({ id: 'NM_000546.6' });
+        expect(model.blastParams?.proteinSequence).toBe('MKV');
+    });
+});
+describe('where a lookup searches', () => {
+    test('feature tracks only, on screen before the whole chromosome', async () => {
+        rpcCall.mockResolvedValue([]);
+        lgv.tracks = [
+            { type: 'AlignmentsTrack', adapter: 'bam' },
+            { type: 'FeatureTrack', adapter: 'genes' },
+        ];
+        lgv.dynamicBlocks.contentBlocks = [
+            {
+                assemblyName: 'hg38',
+                refName: 'chr17',
+                start: 7_661_778.6,
+                end: 7_687_538.2,
+            },
+        ];
+        connectedView();
+        await settle();
+        const asked = rpcCall.mock.calls.map(([, , args]) => [
+            args.adapterConfig,
+            args.regions,
+        ]);
+        expect(asked).toEqual([
+            [
+                'genes',
+                [
+                    {
+                        assemblyName: 'hg38',
+                        refName: 'chr17',
+                        start: 7_661_778,
+                        end: 7_687_539,
+                    },
+                ],
+            ],
+            ['genes', lgv.displayedRegions],
+        ]);
+    });
+});
+describe('two lookups in flight', () => {
+    test('only the later one writes', async () => {
+        const pending = [];
+        rpcCall.mockImplementation(() => new Promise(res => {
+            pending.push(res);
+        }));
+        const model = connectedView();
+        await settle();
+        model.retryLaunch();
+        await settle();
+        expect(pending).toHaveLength(2);
+        pending[1]([transcript('NM_000546.6')]);
+        await settle();
+        const written = model.connectedFeature;
+        pending[0]([transcript('NM_000546.5')]);
+        await settle();
+        expect(written).toMatchObject({ id: 'NM_000546.6' });
+        expect(model.connectedFeature).toBe(written);
+    });
+});

package/dist/MsaViewPanel/runLaunch.d.ts

@@ -26,11 +26,15 @@ interface LaunchedData {
  * Run one launch attempt, owning the AbortController that ties it to the view.
  *
  * The controller lives on the model because two things end a launch and neither
- * is here: the Cancel button, and the disposer `afterCreate` registers. Before
- * it existed, closing a view mid-BLAST left the poller checking EBI for the
- * job's lifetime and then writing to a node that was gone.
+ * is here: the Cancel button, and the disposer `afterCreate` registers. A launch
+ * already holding it is aborted first, so a re-fired autorun replaces the
+ * attempt rather than orphaning one that nothing can cancel.
+ *
+ * Runs untracked: it is called from the launch autoruns, and whatever the
+ * launch body reads before its first await would otherwise become a reason to
+ * launch again.
  */
-export declare function runLaunch({ self, message, launch, onLaunched, }: {
+export declare function runLaunch(args: {
     self: JBrowsePluginMsaViewModel;
     message: string;
     launch: (scope: LaunchScope) => Promise<LaunchedData>;