jbrowse-plugin-msaview 3.4.1 → 3.6.0

package/dist/LaunchMsaView/components/SubmitCancelActions.test.js

@@ -4,6 +4,7 @@ import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 import { LAUNCH_PLACEMENT_KEY } from '../../utils/workspaces';
 import SubmitCancelActions from './SubmitCancelActions';
+import { LaunchPlacementProvider } from './launchPlacement';
 // getSession walks the MST tree, and this component only wants the two actions
 // off the far end of that walk
 vi.mock('@jbrowse/core/util', () => ({
@@ -39,14 +40,43 @@ test('a panel that launches nothing passes no model, and gets no box', () => {
     render(React.createElement(SubmitCancelActions, { onSubmit: () => { }, onCancel: () => { } }));
     expect(toggle()).toBeNull();
 });
-test('clicking it writes the placement the next launch will read', () => {
+test('submitting writes the placement the launch will read', () => {
     render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
     toggle().click();
-    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
     expect(toggle().checked).toBe(false);
+    screen.getByText('Submit').click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
+});
+// the box is a property of this launch until it is launched; a dialog the user
+// backed out of should not have moved where every future one lands
+test('cancelling leaves the stored placement alone', () => {
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
     toggle().click();
+    screen.getByText('Cancel').click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBeNull();
+});
+// a host with no tiling never shows the box, so submitting there must not
+// overwrite the choice the user made on a host that does
+test('a host that cannot tile writes nothing on submit', () => {
+    localStorage.setItem(LAUNCH_PLACEMENT_KEY, 'splitRight');
+    render(React.createElement(SubmitCancelActions, { model: trackModel({}), onSubmit: () => { }, onCancel: () => { } }));
+    screen.getByText('Submit').click();
     expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('splitRight');
-    expect(toggle().checked).toBe(true);
+});
+// every visited tab stays mounted, so each has an actions row of its own; with
+// the answer held per row, ticking the box on one tab and submitting from
+// another wrote the other tab's stale one
+test('every tab in one dialog shares the answer', () => {
+    render(React.createElement(LaunchPlacementProvider, null,
+        React.createElement("div", { "data-testid": "tab-a" },
+            React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } })),
+        React.createElement("div", { "data-testid": "tab-b" },
+            React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { }, submitLabel: "Launch" }))));
+    const boxes = screen.getAllByRole('checkbox');
+    boxes[0].click();
+    expect(boxes[1].checked).toBe(false);
+    screen.getByText('Launch').click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
 });
 test('a stored choice is what the box opens on', () => {
     localStorage.setItem(LAUNCH_PLACEMENT_KEY, 'stack');

package/dist/LaunchMsaView/components/TabPanel.js

@@ -1,5 +1,17 @@
-import React from 'react';
-// this is from MUI example
+import React, { useState } from 'react';
+// Once visited, a panel stays mounted and is hidden with the `hidden` attribute.
+// Unmounting it discarded whatever the user had typed and re-ran every fetch the
+// panel makes on the way back, so switching tabs to compare two of them cost an
+// EBI round trip and the pasted alignment.
+//
+// Lazy on first visit rather than mounted up front, because a panel mounts
+// fetches of its own: rendering all four on open would query the MSA dataset
+// adapter and the BLAST cache for tabs nobody looked at.
 export default function TabPanel({ children, value, index, ...other }) {
-    return (React.createElement("div", { role: "tabpanel", hidden: value !== index, ...other }, value === index ? children : null));
+    const active = value === index;
+    const [visited, setVisited] = useState(active);
+    if (active && !visited) {
+        setVisited(true);
+    }
+    return (React.createElement("div", { role: "tabpanel", hidden: !active, ...other }, visited || active ? children : null));
 }

package/dist/LaunchMsaView/components/TabPanel.test.d.ts

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

package/dist/LaunchMsaView/components/TabPanel.test.js

@@ -0,0 +1,36 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import TabPanel from './TabPanel';
+afterEach(() => {
+    cleanup();
+});
+function Panels({ value }) {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(TabPanel, { value: value, index: "a" },
+            React.createElement(Probe, { name: "a" })),
+        React.createElement(TabPanel, { value: value, index: "b" },
+            React.createElement(Probe, { name: "b" }))));
+}
+const mounted = vi.fn();
+function Probe({ name }) {
+    React.useEffect(() => {
+        mounted(name);
+    }, [name]);
+    return React.createElement("input", { defaultValue: name });
+}
+test('a visited panel keeps its state while another tab is shown', () => {
+    const { rerender } = render(React.createElement(Panels, { value: "a" }));
+    const typed = screen.getByDisplayValue('a');
+    typed.value = 'edited';
+    rerender(React.createElement(Panels, { value: "b" }));
+    rerender(React.createElement(Panels, { value: "a" }));
+    expect(screen.getByDisplayValue('edited')).toBeTruthy();
+    expect(mounted.mock.calls.filter(([n]) => n === 'a')).toHaveLength(1);
+});
+test('an unvisited panel does not mount, so it fetches nothing', () => {
+    mounted.mockClear();
+    render(React.createElement(Panels, { value: "a" }));
+    expect(mounted.mock.calls.map(([n]) => n)).toEqual(['a']);
+});

package/dist/LaunchMsaView/components/TranscriptSelector.d.ts

@@ -1,11 +1,13 @@
 import React from 'react';
+import type { SequenceStatus } from './SequenceStatus';
 import type { Feature } from '@jbrowse/core/util';
-export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, validIds, }: {
+export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, sequenceStatus, validIds, }: {
     feature: Feature;
     options: Feature[];
     selectedId: string;
     selectedTranscript: Feature | undefined;
     setSelectedId: (transcriptId: string) => void;
     proteinSequence: string | undefined;
+    sequenceStatus?: SequenceStatus;
     validIds?: string[];
 }): React.JSX.Element;

package/dist/LaunchMsaView/components/TranscriptSelector.js

@@ -15,7 +15,7 @@ const useStyles = makeStyles()({
         marginLeft: 20,
     },
 });
-export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, validIds, }) {
+export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, sequenceStatus = 'ready', validIds, }) {
     const { classes } = useStyles();
     const [showSequence, setShowSequence] = useState(false);
     return (React.createElement(React.Fragment, null,
@@ -48,5 +48,7 @@ export default function TranscriptSelector({ feature, options, selectedId, selec
                     } }, showSequence ? 'Hide sequence' : 'Show sequence'))),
         showSequence ? (React.createElement(ReadOnlyTextField2, { value: proteinSequence
                 ? `>${getTranscriptDisplayName(selectedTranscript)}\n${proteinSequence}`
-                : 'Loading...' })) : null));
+                : sequenceStatus === 'missing'
+                    ? 'This transcript has no coding sequence, so there is nothing to translate.'
+                    : 'Loading...' })) : null));
 }

package/dist/LaunchMsaView/components/calculateProteinSequence.d.ts

@@ -11,7 +11,10 @@ export declare function revlist(list: Feat[], seqlen: number): {
     type?: string;
     phase?: number;
 }[];
-export declare function getProteinSequenceFromFeature({ feature, seq, }: {
+export declare function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }: {
     seq: string;
     feature: Feature;
+    /** the assembly's code for the feature's contig, `{ chrM: 2 }` in hub
+     * configs; a transl_table on the feature wins */
+    assemblyGeneticCodeId?: number;
 }): string;

package/dist/LaunchMsaView/components/calculateProteinSequence.js

@@ -1,8 +1,9 @@
-import { dedupe, revcom } from '@jbrowse/core/util';
+import { revcom } from '@jbrowse/core/util';
 import { convertCodingSequenceToPeptides } from '@jbrowse/core/util/convertCodingSequenceToPeptides';
-import { getGeneticCode, parseTranslTable } from './geneticCodes';
-// `@jbrowse/core/util/convertCodingSequenceToPeptides` is a deep path, so unlike
-// the `@jbrowse/core/util` barrel it is absent from ReExports and gets bundled
+import { getGeneticCode, parseTranslTable, } from '@jbrowse/core/util/geneticCodes';
+// `@jbrowse/core/util/convertCodingSequenceToPeptides` and
+// `@jbrowse/core/util/geneticCodes` are deep paths, so unlike the
+// `@jbrowse/core/util` barrel they are absent from ReExports and get bundled
 // rather than resolved out of the host's JBrowseExports. That is what makes
 // reusing core's translation safe across every host a config names: this module
 // previously built its codon table at module scope from the barrel's
@@ -21,6 +22,13 @@ export function calculateProteinSequence({ cds, sequence, geneticCodeId, }) {
         codonTable,
     });
 }
+// The CDS list is sorted by start, so adjacent comparison is the whole job.
+function cdsId(feat) {
+    return `${feat.start}-${feat.end}`;
+}
+function dedupe(list) {
+    return list.filter((item, pos, ary) => !pos || cdsId(item) !== cdsId(ary[pos - 1]));
+}
 export function revlist(list, seqlen) {
     return list
         .map(sub => ({
@@ -30,7 +38,7 @@ export function revlist(list, seqlen) {
     }))
         .toSorted((a, b) => a.start - b.start);
 }
-export function getProteinSequenceFromFeature({ feature, seq, }) {
+export function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }) {
     const { subfeatures, start, strand } = feature.toJSON();
     const cds = dedupe(subfeatures
         ?.toSorted((a, b) => a.start - b.start)
@@ -39,15 +47,17 @@ export function getProteinSequenceFromFeature({ feature, seq, }) {
         start: sub.start - start,
         end: sub.end - start,
     }))
-        .filter(subfeature => subfeature.type === 'CDS') ?? [], feat => `${feat.start}-${feat.end}`);
-    // a mitochondrial gene declares e.g. transl_table=2, so it translates with
-    // NCBI table 2 rather than the standard code. GFF3 usually carries the
-    // attribute on the CDS rather than the transcript, so check both.
+        .filter(subfeature => subfeature.type === 'CDS') ?? []);
+    // RefSeq declares transl_table=2 on a mitochondrial CDS, usually on the CDS
+    // rather than the transcript. GENCODE and UCSC declare nothing, so without
+    // the assembly's code all 13 human mitochondrial proteins read TGA as a stop
+    // and ATA as I.
     const cdsSubfeature = feature
         .get('subfeatures')
         ?.find((f) => f.get('type')?.toLowerCase() === 'cds');
     const geneticCodeId = parseTranslTable(feature.get('transl_table')) ??
-        parseTranslTable(cdsSubfeature?.get('transl_table'));
+        parseTranslTable(cdsSubfeature?.get('transl_table')) ??
+        assemblyGeneticCodeId;
     return calculateProteinSequence({
         cds: strand === -1 ? revlist(cds, seq.length) : cds,
         sequence: strand === -1 ? revcom(seq) : seq,

package/dist/LaunchMsaView/components/fetchSeq.d.ts

@@ -5,4 +5,7 @@ export declare function fetchSeq({ start, end, refName, session, assemblyName, }
     refName: string;
     assemblyName: string;
     session: AbstractSessionModel;
-}): Promise<string>;
+}): Promise<{
+    seq: string;
+    assemblyGeneticCodeId: number | undefined;
+}>;

package/dist/LaunchMsaView/components/fetchSeq.js

@@ -6,17 +6,27 @@ export async function fetchSeq({ start, end, refName, session, assemblyName, })
         throw new Error('assembly not found');
     }
     const sessionId = 'getSequence';
-    const feats = (await rpcManager.call(sessionId, 'CoreGetFeatures', {
+    // a named object keeps sessionId, which v4 hosts read from the args
+    const args = {
         adapterConfig: getConf(assembly, ['sequence', 'adapter']),
         sessionId,
         regions: [
             {
                 start,
                 end,
-                refName: assembly.getCanonicalRefName(refName),
+                refName: assembly.getCanonicalRefName(refName) ?? refName,
                 assemblyName,
             },
         ],
-    }));
-    return feats[0]?.get('seq') ?? '';
+    };
+    const feats = await rpcManager.call(sessionId, 'CoreGetFeatures', args);
+    return {
+        seq: feats[0]?.get('seq') ?? '',
+        // travels with the sequence because the caller needs both to translate, and
+        // resolving the assembly twice to get them is the shape that lost it
+        assemblyGeneticCodeId: geneticCodeId(assembly, refName),
+    };
+}
+function geneticCodeId(assembly, refName) {
+    return assembly.getGeneticCodeId?.(refName);
 }

package/dist/LaunchMsaView/components/launchPlacement.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type PlacementState = [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+export declare function LaunchPlacementProvider({ children, }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+/** the dialog's answer, or a private one for a panel rendered outside it */
+export declare function useLaunchPlacement(): PlacementState;
+export {};

package/dist/LaunchMsaView/components/launchPlacement.js

@@ -0,0 +1,25 @@
+import React, { createContext, useContext, useState } from 'react';
+import { readLaunchPlacement } from '../../utils/workspaces';
+/**
+ * Whether the launch opens beside the genome view — one answer for the whole
+ * dialog, not one per tab.
+ *
+ * Every tab the user visits stays mounted, and the checkbox lives in each
+ * panel's actions row, so a `useState` there gave each tab its own copy of the
+ * answer: ticking the box on one tab and submitting from another wrote the
+ * other tab's stale one.
+ *
+ * Context rather than a prop through all five panels, none of which has any
+ * other business with placement.
+ */
+const LaunchPlacementContext = createContext(undefined);
+export function LaunchPlacementProvider({ children, }) {
+    const state = useState(() => readLaunchPlacement() === 'splitRight');
+    return (React.createElement(LaunchPlacementContext.Provider, { value: state }, children));
+}
+/** the dialog's answer, or a private one for a panel rendered outside it */
+export function useLaunchPlacement() {
+    const shared = useContext(LaunchPlacementContext);
+    const own = useState(() => readLaunchPlacement() === 'splitRight');
+    return shared ?? own;
+}

package/dist/LaunchMsaView/components/useFeatureSequence.d.ts

@@ -9,7 +9,9 @@ export declare function useFeatureSequence({ view, feature, }: {
     proteinSequence: string;
     sequence: {
         seq: string;
+        assemblyGeneticCodeId: number | undefined;
     } | undefined;
     error: unknown;
+    isLoading: boolean;
 };
 export {};

package/dist/LaunchMsaView/components/useFeatureSequence.js

@@ -4,25 +4,28 @@ import { getProteinSequenceFromFeature } from './calculateProteinSequence';
 import { fetchSeq } from './fetchSeq';
 export function useFeatureSequence({ view, feature, }) {
     const assemblyName = view?.assemblyNames?.[0];
-    const { data: sequence, error } = useFetch(feature && assemblyName
+    const { data: sequence, error, isLoading, } = useFetch(feature && assemblyName
         ? [feature.id(), assemblyName, 'feature-sequence']
         : null, async () => {
         const { start, end, refName } = feature.toJSON();
-        return {
-            seq: await fetchSeq({
-                start,
-                end,
-                refName,
-                assemblyName: assemblyName,
-                session: getSession(view),
-            }),
-        };
+        return fetchSeq({
+            start,
+            end,
+            refName,
+            assemblyName: assemblyName,
+            session: getSession(view),
+        });
     });
     return {
         proteinSequence: sequence && feature
-            ? getProteinSequenceFromFeature({ seq: sequence.seq, feature })
+            ? getProteinSequenceFromFeature({
+                seq: sequence.seq,
+                feature,
+                assemblyGeneticCodeId: sequence.assemblyGeneticCodeId,
+            })
             : '',
         sequence,
         error,
+        isLoading,
     };
 }

package/dist/LaunchMsaView/components/useTranscriptSelection.d.ts

@@ -1,10 +1,17 @@
+import type { SequenceStatus } from './SequenceStatus';
 import type { Feature } from '@jbrowse/core/util';
-export declare function useTranscriptSelection({ feature, view, validIds, }: {
+export declare function useTranscriptSelection({ feature, view, validIds, preferredTranscriptId, }: {
     feature: Feature;
     view: {
         assemblyNames?: string[];
     } | undefined;
     validIds?: string[];
+    /**
+     * the isoform the user right-clicked, when the dialog opened on its gene.
+     * Ignored when this gene does not carry it, so a stale id falls back to the
+     * longest transcript rather than selecting nothing.
+     */
+    preferredTranscriptId?: string;
 }): {
     options: Feature[];
     selectedId: string;
@@ -12,5 +19,7 @@ export declare function useTranscriptSelection({ feature, view, validIds, }: {
     selectedTranscript: Feature | undefined;
     proteinSequence: string;
     error: unknown;
+    isLoading: boolean;
+    sequenceStatus: SequenceStatus;
     validIds: string[] | undefined;
 };

package/dist/LaunchMsaView/components/useTranscriptSelection.js

@@ -16,12 +16,28 @@ function pickSelectedId(currentId, options, validIds) {
     const firstValid = options.find(isValid);
     return firstValid ? getId(firstValid) : currentId;
 }
-export function useTranscriptSelection({ feature, view, validIds, }) {
+/**
+ * Submit is disabled until the query sequence is in hand, and a grey button
+ * reads the same whether the translation is on its way or was never going to
+ * arrive. `missing` is the second case: the feature has no CDS to translate,
+ * which the dialog never said.
+ */
+function sequenceStatus({ error, isLoading, proteinSequence, }) {
+    if (error) {
+        return 'error';
+    }
+    if (isLoading) {
+        return 'loading';
+    }
+    return proteinSequence ? 'ready' : 'missing';
+}
+export function useTranscriptSelection({ feature, view, validIds, preferredTranscriptId, }) {
     const options = useMemo(() => getSortedTranscriptFeatures(feature), [feature]);
-    const [selectedId, setSelectedId] = useState(() => getId(options[0]));
+    const [selectedId, setSelectedId] = useState(() => getId(options.find(opt => featureMatchesId(opt, preferredTranscriptId ?? '')) ??
+        options[0]));
     const validatedSelectedId = pickSelectedId(selectedId, options, validIds);
     const selectedTranscript = options.find(val => getId(val) === validatedSelectedId);
-    const { proteinSequence, error } = useFeatureSequence({
+    const { proteinSequence, error, isLoading } = useFeatureSequence({
         view,
         feature: selectedTranscript,
     });
@@ -32,6 +48,8 @@ export function useTranscriptSelection({ feature, view, validIds, }) {
         selectedTranscript,
         proteinSequence,
         error,
+        isLoading,
+        sequenceStatus: sequenceStatus({ error, isLoading, proteinSequence }),
         validIds,
     };
 }

package/dist/LaunchMsaView/components/useTranscriptSelection.test.d.ts

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

package/dist/LaunchMsaView/components/useTranscriptSelection.test.js

@@ -0,0 +1,57 @@
+// @vitest-environment jsdom
+import { SimpleFeature } from '@jbrowse/core/util';
+import { renderHook } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { useTranscriptSelection } from './useTranscriptSelection';
+function transcript(id, cdsLength) {
+    return {
+        uniqueId: id,
+        name: id,
+        refName: 'chr1',
+        start: 0,
+        end: cdsLength,
+        type: 'mRNA',
+        subfeatures: [
+            {
+                uniqueId: `${id}-cds`,
+                refName: 'chr1',
+                start: 0,
+                end: cdsLength,
+                type: 'CDS',
+            },
+        ],
+    };
+}
+// the picker sorts by translated length, so the clicked isoform is deliberately
+// not the one that would be chosen by default
+const gene = new SimpleFeature({
+    uniqueId: 'gene1',
+    name: 'TP53',
+    refName: 'chr1',
+    start: 0,
+    end: 900,
+    type: 'gene',
+    subfeatures: [transcript('short', 300), transcript('long', 900)],
+});
+// `view` is left out so useFeatureSequence has no assembly to fetch against and
+// never reaches the session; only the selection is under test here
+function selection(preferredTranscriptId) {
+    return renderHook(() => useTranscriptSelection({
+        feature: gene,
+        view: undefined,
+        preferredTranscriptId,
+    })).result.current;
+}
+describe('useTranscriptSelection', () => {
+    test('opens on the longest transcript with nothing preferred', () => {
+        expect(selection().selectedId).toBe('long');
+    });
+    // climbing to the gene is what puts every isoform in the picker, and it threw
+    // away which one the right-click landed on
+    test('opens on the isoform the user clicked', () => {
+        expect(selection('short').selectedId).toBe('short');
+    });
+    test('ignores a preferred id this gene does not carry', () => {
+        expect(selection('some_other_transcript').selectedId).toBe('long');
+    });
+});

package/dist/LaunchMsaView/detectQueryRow.d.ts

@@ -18,6 +18,17 @@ export interface QueryRowMatch {
     quality: MatchQuality;
     /** identity over the compared region, 0-1 */
     identity: number;
+    /**
+     * Transcript residues before the row's first residue, so transcript position
+     * = row position + offset. BLAST reports the aligned region, so a row is
+     * often the query with its termini trimmed, and mapping its first residue to
+     * the transcript's first residue would put every navigation off by the
+     * trimmed amount. Negative when the row is the longer of the two.
+     *
+     * Zero for a `similar` match, which is the one arm this cannot measure: the
+     * row is not the query, so where it starts is a guess.
+     */
+    offset: number;
 }
 export interface MsaQueryRow {
     /** every row name, in file order, for the picker to offer */

package/dist/LaunchMsaView/detectQueryRow.js

@@ -70,20 +70,27 @@ function bestMatch(parsed, names, query) {
         }
         if (row === query) {
             // nothing beats an exact match, and a second one would be a duplicate row
-            return { name, quality: 'exact', identity: 1 };
+            return { name, quality: 'exact', identity: 1, offset: 0 };
         }
         // BLAST reports the aligned region, so the row is often the query trimmed
         // at one or both ends rather than the whole protein
-        if (query.includes(row) || row.includes(query)) {
+        const contained = query.indexOf(row);
+        const containing = row.indexOf(query);
+        if (contained !== -1 || containing !== -1) {
             const coverage = Math.min(row.length, query.length) / Math.max(row.length, query.length);
             if (coverage >= PARTIAL_COVERAGE_FLOOR) {
-                candidates.push({ name, quality: 'partial', identity: coverage });
+                candidates.push({
+                    name,
+                    quality: 'partial',
+                    identity: coverage,
+                    offset: contained === -1 ? -containing : contained,
+                });
             }
             continue;
         }
         const identity = identityOverOverlap(row, query);
         if (identity >= SIMILARITY_FLOOR) {
-            candidates.push({ name, quality: 'similar', identity });
+            candidates.push({ name, quality: 'similar', identity, offset: 0 });
         }
     }
     // an exact match returns above, so only these two can be here

package/dist/LaunchMsaView/detectQueryRow.test.js

@@ -33,6 +33,36 @@ describe('findQueryRow', () => {
             quality: 'partial',
         });
     });
+    // the offset is what the view maps genome coordinates through: without it an
+    // N-terminally trimmed row puts every click five codons off, silently
+    test('says how far into the protein a trimmed row starts', () => {
+        const trimmed = `>aligned_query\n${protein.slice(5, 40)}\n>hit_one\nWRONGWRONGWRONGWRONG\n`;
+        expect(findQueryRow(trimmed, protein).match).toMatchObject({
+            name: 'aligned_query',
+            quality: 'partial',
+            offset: 5,
+        });
+    });
+    test('an exact match starts where the protein does', () => {
+        expect(findQueryRow(clustal, protein).match?.offset).toBe(0);
+    });
+    test('a row running past the protein gets a negative offset', () => {
+        const extended = `>longer_row\nMMM${protein}\n`;
+        expect(findQueryRow(extended, protein).match).toMatchObject({
+            name: 'longer_row',
+            quality: 'partial',
+            offset: -3,
+        });
+    });
+    // the one arm with nothing to measure: a 90%-identical row is not the query,
+    // so QueryRowSelector warns rather than claiming a match
+    test('a merely similar row claims no offset', () => {
+        const similar = protein.slice(0, 30) + 'W' + protein.slice(31);
+        expect(findQueryRow(`>near\n${similar}\n`, protein).match).toMatchObject({
+            quality: 'similar',
+            offset: 0,
+        });
+    });
     // the failure that matters: silently wiring the view to a homolog would look
     // like it worked, and every navigation afterwards would land in the wrong place
     test('returns nothing when only diverged homologs are present', () => {

package/dist/LaunchMsaView/index.js

@@ -1,5 +1,6 @@
 import { getContainingTrack, getSession } from '@jbrowse/core/util';
 import AddIcon from '@mui/icons-material/Add';
+import { isCodingFeature } from './codingFeature';
 import LaunchMsaViewDialog from './components/LaunchMsaViewDialog';
 import { launchTarget } from './launchTarget';
 function isDisplay(elt) {
@@ -9,19 +10,37 @@ function isDisplay(elt) {
 // built: contextMenuItems runs on every right-click and, on a host whose base
 // method reads `this`, is the one place a plugin can take the whole menu down.
 // Keeping it to a pure read of the display is also what lets a test call it.
-function openDialog(self, feature) {
+function featureName(feature) {
+    return feature.get('name') ?? feature.get('id') ?? 'This feature';
+}
+function openDialog(self, target) {
     const track = getContainingTrack(self);
     const session = getSession(track);
-    feature()
-        .then(f => {
-        if (f) {
-            session.queueDialog(handleClose => [
-                LaunchMsaViewDialog,
-                { model: track, handleClose, feature: f },
-            ]);
+    const { preferredTranscriptId } = target;
+    const open = (feature) => {
+        session.queueDialog(handleClose => [
+            LaunchMsaViewDialog,
+            { model: track, handleClose, feature, preferredTranscriptId },
+        ]);
+    };
+    if ('feature' in target) {
+        open(target.feature);
+        return;
+    }
+    target
+        .fetchFeature()
+        .then(feature => {
+        if (!feature) {
+            session.notify('Could not load feature for MSA view', 'warning');
+        }
+        else if (!isCodingFeature(feature)) {
+            // the canvas hit test carries a type and nothing else, so this is the
+            // first point at which the CDS can be looked for. Saying so beats
+            // opening a dialog whose Submit never leaves grey.
+            session.notify(`${featureName(feature)} has no coding sequence, so there is no protein to align`, 'info');
         }
         else {
-            session.notify('Could not load feature for MSA view', 'warning');
+            open(feature);
         }
     })
         .catch((e) => {