jbrowse-plugin-msaview 3.4.1 → 3.6.0

package/dist/LaunchMsaView/launchTarget.d.ts

@@ -1,3 +1,4 @@
+import { isGeneLikeType } from './codingFeature';
 import type { MenuItem } from '@jbrowse/core/ui';
 import type { Feature } from '@jbrowse/core/util';
 export interface ContextMenuInfo {
@@ -13,13 +14,40 @@ export interface DisplayModel {
     fetchFullFeature?: (featureId: string, displayedRegionIndex: number) => Promise<Feature | undefined>;
     contextMenuFeature?: Feature;
 }
-export declare function isGeneLikeType(type: unknown): boolean;
 /**
- * How to get the right-clicked feature, or nothing when there is no gene to
- * launch on. Both host shapes reduce to a thunk, so the menu item is built and
- * the dialog is opened by one code path — and the same gene test decides both.
- * The strict three-name set the legacy branch used to carry disagreed with the
- * loose one above, so a `lnc_RNA` offered the menu item on a 4.3 host and not
- * on a 3.7 one.
+ * What the menu item launches on. A legacy host hands over the whole feature,
+ * so whether it codes for anything is known while the menu is built; a canvas
+ * host's hit test carries a type and an id, so that question can only be
+ * answered after the fetch, and the caller answers it there.
  */
-export declare function launchTarget(self: DisplayModel): (() => Promise<Feature | undefined>) | undefined;
+interface ClickedTranscript {
+    /**
+     * The isoform the click actually landed on, when the dialog opens on its
+     * gene. Climbing to the gene is what puts every isoform in the picker, and it
+     * threw away which one the user pointed at: the picker then opened on the
+     * longest transcript, and on a v4 host that is the only place the choice was
+     * ever stated.
+     */
+    preferredTranscriptId?: string;
+}
+export type MenuTarget = (ClickedTranscript & {
+    feature: Feature;
+}) | (ClickedTranscript & {
+    fetchFeature: () => Promise<Feature | undefined>;
+});
+export { isGeneLikeType };
+/**
+ * How to get the right-clicked feature, or nothing when there is nothing to
+ * launch on. Both host shapes reduce to one target, so the menu item is built
+ * and the dialog is opened by one code path — and the same gene test decides
+ * both. The strict three-name set the legacy branch used to carry disagreed
+ * with the loose one above, so a `lnc_RNA` offered the menu item on a 4.3 host
+ * and not on a 3.7 one.
+ *
+ * Gene-like is not enough on its own: an lncRNA has no protein to align, and
+ * accepting it opened a dialog whose Submit never left grey, with nothing
+ * saying why. Where the whole feature is in hand the CDS decides here -- but
+ * only where there are subfeatures to read it off, since a feature that came
+ * with none has not answered the question.
+ */
+export declare function launchTarget(self: DisplayModel): MenuTarget | undefined;

package/dist/LaunchMsaView/launchTarget.js

@@ -1,3 +1,4 @@
+import { geneLikeRoot, isGeneLikeType, isKnownNonCoding } from './codingFeature';
 // Read off the clicked item rather than off the display.
 //
 // LinearBasicDisplay used to publish an `isGeneLike` getter and this gated on
@@ -12,17 +13,20 @@
 // costs one comparison. Deliberately the same loose case-insensitive test the
 // host applies (`isGeneLikeType` in collapseIntronsMenu.ts): real GFFs carry
 // 'mRNA', 'lnc_RNA', 'protein_coding_gene', 'transcript'.
-export function isGeneLikeType(type) {
-    const t = String(type ?? '').toLowerCase();
-    return t.includes('gene') || t.includes('rna') || t.includes('transcript');
-}
+export { isGeneLikeType };
 /**
- * How to get the right-clicked feature, or nothing when there is no gene to
- * launch on. Both host shapes reduce to a thunk, so the menu item is built and
- * the dialog is opened by one code path — and the same gene test decides both.
- * The strict three-name set the legacy branch used to carry disagreed with the
- * loose one above, so a `lnc_RNA` offered the menu item on a 4.3 host and not
- * on a 3.7 one.
+ * How to get the right-clicked feature, or nothing when there is nothing to
+ * launch on. Both host shapes reduce to one target, so the menu item is built
+ * and the dialog is opened by one code path — and the same gene test decides
+ * both. The strict three-name set the legacy branch used to carry disagreed
+ * with the loose one above, so a `lnc_RNA` offered the menu item on a 4.3 host
+ * and not on a 3.7 one.
+ *
+ * Gene-like is not enough on its own: an lncRNA has no protein to align, and
+ * accepting it opened a dialog whose Submit never left grey, with nothing
+ * saying why. Where the whole feature is in hand the CDS decides here -- but
+ * only where there are subfeatures to read it off, since a feature that came
+ * with none has not answered the question.
  */
 export function launchTarget(self) {
     const info = self.contextMenuInfo;
@@ -32,11 +36,17 @@ export function launchTarget(self) {
     // rejects the click can only answer with some other feature
     if (info && fetchFullFeature) {
         return isGeneLikeType(info.item.type)
-            ? () => fetchFullFeature(info.item.featureId, info.displayedRegionIndex)
+            ? {
+                fetchFeature: () => fetchFullFeature(info.item.featureId, info.displayedRegionIndex),
+            }
             : undefined;
     }
     const legacy = self.contextMenuFeature;
-    return legacy && isGeneLikeType(legacy.get('type'))
-        ? () => Promise.resolve(legacy)
+    if (!legacy) {
+        return undefined;
+    }
+    const root = geneLikeRoot(legacy);
+    return isGeneLikeType(root.get('type')) && !isKnownNonCoding(root)
+        ? { feature: root, preferredTranscriptId: legacy.id() }
         : undefined;
 }

package/dist/LaunchMsaView/launchTarget.test.js

@@ -1,19 +1,36 @@
+import { SimpleFeature } from '@jbrowse/core/util';
 import { describe, expect, test } from 'vitest';
 import { isGeneLikeType, launchTarget } from './launchTarget';
-function feature(type) {
-    return {
-        get: (key) => (key === 'type' ? type : undefined),
-    };
+function feature(type, subfeatures = ['CDS']) {
+    return new SimpleFeature({
+        uniqueId: type,
+        refName: 'chr1',
+        start: 0,
+        end: 100,
+        type,
+        subfeatures: subfeatures.map((t, i) => ({
+            uniqueId: `${type}-${i}`,
+            refName: 'chr1',
+            start: 0,
+            end: 100,
+            type: t,
+        })),
+    });
 }
 const modernHost = (type) => ({
     contextMenuItems: () => [],
     contextMenuInfo: { item: { featureId: 'f1', type }, displayedRegionIndex: 0 },
     fetchFullFeature: (featureId) => Promise.resolve(feature(`fetched:${featureId}`)),
 });
-const legacyHost = (type) => ({
+const legacyHost = (feat) => ({
     contextMenuItems: () => [],
-    contextMenuFeature: feature(type),
+    contextMenuFeature: feat,
 });
+async function fetched(target) {
+    return target && 'fetchFeature' in target
+        ? await target.fetchFeature()
+        : undefined;
+}
 describe('isGeneLikeType', () => {
     test.each(['gene', 'mRNA', 'transcript', 'lnc_RNA', 'protein_coding_gene'])('accepts %s', type => {
         expect(isGeneLikeType(type)).toBe(true);
@@ -25,8 +42,8 @@ describe('isGeneLikeType', () => {
 describe('launchTarget', () => {
     test('resolves the clicked feature through fetchFullFeature', async () => {
         const target = launchTarget(modernHost('mRNA'));
-        expect(target).toBeDefined();
-        expect((await target())?.get('type')).toBe('fetched:f1');
+        expect(await fetched(target)).toBeDefined();
+        expect((await fetched(target))?.get('type')).toBe('fetched:f1');
     });
     test('offers nothing for a non-gene click', () => {
         expect(launchTarget(modernHost('CDS'))).toBeUndefined();
@@ -37,18 +54,66 @@ describe('launchTarget', () => {
     });
     // v3.7.0 hosts have contextMenuFeature and nothing else; dropping this
     // fallback once took "Launch MSA view" off every host in the wild.
-    test('falls back to a synchronous contextMenuFeature', async () => {
-        const target = launchTarget(legacyHost('mRNA'));
-        expect(target).toBeDefined();
-        expect((await target())?.get('type')).toBe('mRNA');
+    test('falls back to a synchronous contextMenuFeature', () => {
+        const target = launchTarget(legacyHost(feature('mRNA')));
+        expect(target && 'feature' in target && target.feature.get('type')).toBe('mRNA');
     });
     test('applies the same gene test on both host shapes', () => {
-        expect(launchTarget(legacyHost('lnc_RNA'))).toBeDefined();
-        expect(launchTarget(legacyHost('exon'))).toBeUndefined();
+        expect(launchTarget(legacyHost(feature('lnc_RNA')))).toBeDefined();
+        expect(launchTarget(legacyHost(feature('exon')))).toBeUndefined();
+    });
+    // gene-like is not enough: an lncRNA translates to nothing, and offering the
+    // item opened a dialog whose Submit never left grey
+    test('declines a gene-like feature with no CDS below it', () => {
+        expect(launchTarget(legacyHost(feature('lnc_RNA', ['exon'])))).toBeUndefined();
+    });
+    // a legacy host can hand over a bare record whose children are a separate
+    // query, and declining it takes the item off an ordinary gene with no word
+    test('offers the item for a gene that arrived with no subfeatures', () => {
+        expect(launchTarget(legacyHost(feature('gene', [])))).toBeDefined();
+    });
+    // a click on an isoform should open the dialog on the gene, so every
+    // transcript is there to pick from
+    test('climbs to the gene from a clicked isoform', () => {
+        const gene = new SimpleFeature({
+            uniqueId: 'gene',
+            refName: 'chr1',
+            start: 0,
+            end: 100,
+            type: 'gene',
+            subfeatures: [
+                {
+                    uniqueId: 'mrna',
+                    refName: 'chr1',
+                    start: 0,
+                    end: 100,
+                    type: 'mRNA',
+                    subfeatures: [
+                        {
+                            uniqueId: 'cds',
+                            refName: 'chr1',
+                            start: 0,
+                            end: 100,
+                            type: 'CDS',
+                        },
+                    ],
+                },
+            ],
+        });
+        const mrna = gene.get('subfeatures')[0];
+        const target = launchTarget(legacyHost(mrna));
+        expect(target && 'feature' in target && target.feature).toBe(gene);
+        // the gene is what the dialog opens on, but the picker still opens on the
+        // isoform the click landed on -- on a v4 host that click is the only place
+        // the choice is ever stated
+        expect(target?.preferredTranscriptId).toBe(mrna.id());
     });
     // a host that has both shapes must not fall through to the legacy branch and
     // launch on a stale feature when the click was not on a gene
     test('a non-gene click on a host carrying both shapes offers nothing', () => {
-        expect(launchTarget({ ...modernHost('CDS'), ...legacyHost('mRNA') })).toBeUndefined();
+        expect(launchTarget({
+            ...modernHost('CDS'),
+            ...legacyHost(feature('mRNA')),
+        })).toBeUndefined();
     });
 });

package/dist/LaunchMsaView/useQueryRowName.d.ts

@@ -6,10 +6,23 @@
  * effect writing back into state, and an override survives later edits to the
  * alignment because it is the one thing actually stored.
  */
+/**
+ * The row to launch with. Detection by residues is the answer wherever it has
+ * one -- aligners rename the query on the way through, so a name proves
+ * nothing -- but a caller with a naming convention of its own can offer it as a
+ * fallback, and it is taken only when the alignment really carries that row.
+ * An empty result means there is no query row, which a launch has to refuse:
+ * the view opens, renders, and then never navigates.
+ */
+export declare function resolveQueryRowName(queryRow: {
+    querySeqName: string;
+    names: string[];
+}, fallback: string): string;
 export declare function useQueryRowName(msaText: string, proteinSequence: string): {
     detected: import("./detectQueryRow").QueryRowMatch | undefined;
     names: string[];
     querySeqName: string;
+    querySeqOffset: number;
     setQuerySeqName: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     isAutoDetected: boolean;
 };

package/dist/LaunchMsaView/useQueryRowName.js

@@ -8,15 +8,30 @@ import { findQueryRow } from './detectQueryRow';
  * effect writing back into state, and an override survives later edits to the
  * alignment because it is the one thing actually stored.
  */
+/**
+ * The row to launch with. Detection by residues is the answer wherever it has
+ * one -- aligners rename the query on the way through, so a name proves
+ * nothing -- but a caller with a naming convention of its own can offer it as a
+ * fallback, and it is taken only when the alignment really carries that row.
+ * An empty result means there is no query row, which a launch has to refuse:
+ * the view opens, renders, and then never navigates.
+ */
+export function resolveQueryRowName(queryRow, fallback) {
+    return (queryRow.querySeqName || (queryRow.names.includes(fallback) ? fallback : ''));
+}
 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 { names, match } = useMemo(() => findQueryRow(msaText, proteinSequence), [msaText, proteinSequence]);
+    const querySeqName = override ?? match?.name ?? '';
     return {
         detected: match,
         names,
-        querySeqName: override ?? match?.name ?? '',
+        querySeqName,
+        // only the detected row's offset is known; a row the user picked instead is
+        // taken at face value, residue 1 to residue 1
+        querySeqOffset: querySeqName === match?.name ? match.offset : 0,
         setQuerySeqName: setOverride,
         isAutoDetected: override === undefined && !!match,
     };

package/dist/LaunchMsaView/useQueryRowName.test.d.ts

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

package/dist/LaunchMsaView/useQueryRowName.test.js

@@ -0,0 +1,40 @@
+// @vitest-environment jsdom
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { resolveQueryRowName, 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);
+    });
+});
+// a pre-loaded dataset names its rows by a convention of its own, and the
+// residues can be too diverged for detection to find the row that is right
+// there
+describe('resolveQueryRowName', () => {
+    const names = ['ENST1_hg38', 'mm39', 'rn7'];
+    test('prefers the detected or picked row over any fallback', () => {
+        expect(resolveQueryRowName({ querySeqName: 'mm39', names }, 'ENST1_hg38')).toBe('mm39');
+    });
+    test('falls back to a name the alignment actually carries', () => {
+        expect(resolveQueryRowName({ querySeqName: '', names }, 'ENST1_hg38')).toBe('ENST1_hg38');
+    });
+    // the whole bug: the old panel launched with this name whether or not the
+    // file had the row, and a name no row carries navigates nowhere
+    test('answers nothing for a fallback the alignment does not carry', () => {
+        expect(resolveQueryRowName({ querySeqName: '', names }, 'ENST9_hg38')).toBe('');
+    });
+});

package/dist/LaunchMsaView/util.js

@@ -2,11 +2,14 @@ import { getContainingView, sum } from '@jbrowse/core/util';
 export function getLinearGenomeView(model) {
     return getContainingView(model);
 }
+function isNonEmptyString(v) {
+    return typeof v === 'string' && v !== '';
+}
 function uniqueDefined(vals) {
-    return [...new Set(vals.filter((v) => !!v))];
+    return [...new Set(vals.filter(isNonEmptyString))];
 }
 function joinDefined(sep, parts) {
-    return parts.filter((p) => !!p).join(sep);
+    return parts.filter(isNonEmptyString).join(sep);
 }
 export function getTranscriptFeatures(feature) {
     // check if we are looking at a 'two-level' or 'three-level' feature by

package/dist/LaunchMsaViewExtensionPoint/index.js

@@ -1,15 +1,16 @@
 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).
@@ -27,6 +28,7 @@ export default function LaunchMsaViewExtensionPointF(pluginManager) {
         };
         launchMsaView(session, {
             ...rest,
+            ...(searchParams ? { blastParams: searchParams } : {}),
             data,
             ...(treeFileLocation
                 ? {

package/dist/LaunchMsaViewExtensionPoint/index.test.js

@@ -32,6 +32,27 @@ test('a file location travels through init', () => {
         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({

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -12,16 +12,19 @@ export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
  * 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 declare function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel): void;
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
- * request, and clearing them on success is what marks it done. They are left in
- * place on failure so the error stays attributable to a specific request; the
- * autorun's only tracked read is orthologParams itself, so nothing refires
- * until a new request replaces them.
+ * request, and `launchCompleted` is what marks it done. They are left in place
+ * either way -- on failure so the error stays attributable to a specific
+ * request, and on success because they are the only durable statement of what
+ * the view is, which is what a stored alignment that expired is rebuilt from.
+ * The autorun tracks those two reads alone, so nothing refires until a new
+ * request replaces them or a retry clears the mark.
  */
 export declare function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel): void;
 export declare function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel): void;

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -8,8 +8,10 @@ import { loadProteinDomains } from './loadProteinDomains';
 import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
 import { runLaunch } from './runLaunch';
 import { getProteinViews } from './structureConnection';
-import { getUniprotIdFromAlphaFoldUrl, hasQueryRow } from './util';
-const EXPIRED_MESSAGE = "This view's alignment is no longer in browser storage. Stored alignments are kept for 7 days after they were last used, and are lost when site data is cleared. Relaunch the alignment to rebuild it.";
+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.";
+const RELAUNCHABLE = ' Retry runs the original search again and rebuilds it.';
+const START_OVER = ' Relaunch it from the gene to rebuild it.';
 export function loadStoredData(self) {
     const { dataStoreId, rows } = self;
     if (dataStoreId && rows.length === 0) {
@@ -35,10 +37,16 @@ export function loadStoredData(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
+                    // "Return to import form" actually return instead of landing back
+                    // here. The request that built the alignment is kept, though: it is
+                    // the whole of a retry, and dropping it left the user reading an
+                    // apology with nothing to press.
                     transaction(() => {
                         self.setDataStoreId(undefined);
-                        self.setError(new Error(EXPIRED_MESSAGE));
+                        self.setError(new Error(EXPIRED_MESSAGE +
+                            ((self.blastParams ?? self.orthologParams)
+                                ? RELAUNCHABLE
+                                : START_OVER)));
                     });
                 }
             }
@@ -73,16 +81,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;
@@ -111,31 +123,47 @@ export function storeDataToIndexedDB(self) {
 }
 /**
  * Same shape as launchBlastIfNeeded, for the ortholog path: the params ARE the
- * request, and clearing them on success is what marks it done. They are left in
- * place on failure so the error stays attributable to a specific request; the
- * autorun's only tracked read is orthologParams itself, so nothing refires
- * until a new request replaces them.
+ * request, and `launchCompleted` is what marks it done. They are left in place
+ * either way -- on failure so the error stays attributable to a specific
+ * request, and on success because they are the only durable statement of what
+ * the view is, which is what a stored alignment that expired is rebuilt from.
+ * The autorun tracks those two reads alone, so nothing refires until a new
+ * request replaces them or a retry clears the mark.
  */
 export function launchOrthologsIfNeeded(self) {
-    if (self.orthologParams) {
+    if (self.orthologParams &&
+        !self.launchCompleted &&
+        !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Resolving orthologs',
             launch: scope => doLaunchOrthologs({ self, scope }),
+            // marked rather than dropped: the request is the only durable statement
+            // of what this view is, and a view whose stored alignment expired runs it
+            // again
             onLaunched: () => {
-                self.setOrthologParams(undefined);
+                self.setLaunchCompleted(true);
             },
         });
     }
 }
+/**
+ * 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 && !self.launchCompleted && !awaitingTranscript(self)) {
         runLaunch({
             self,
             message: 'Submitting query',
             launch: scope => doLaunchBlast({ self, scope }),
             onLaunched: () => {
-                self.setBlastParams(undefined);
+                self.setLaunchCompleted(true);
             },
         });
     }
@@ -167,15 +195,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 +245,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 +281,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 +298,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) {