jbrowse-plugin-msaview 3.5.0 → 3.7.0

package/dist/LaunchMsaView/components/launchConnectedView.js

@@ -0,0 +1,39 @@
+import { useState } from 'react';
+import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../utils/launchMsaView';
+/** how a view whose alignment the plugin builds opens */
+export const builtAlignmentLook = {
+    drawNodeBubbles: true,
+    colWidth: 10,
+    rowHeight: 12,
+};
+/**
+ * Every dialog launch: an MSA view tied to the genome view it came from, and
+ * through `feature` to the transcript whose codons its query row is read by.
+ */
+export function launchConnectedView({ view, feature, placement, ...snapshot }) {
+    launchMsaView(getSession(view), {
+        placement,
+        connectedViewId: view.id,
+        connectedFeature: feature?.toJSON(),
+        ...snapshot,
+    });
+}
+/** runs a panel's launch, closing the dialog on success and keeping the error */
+export function useLaunchSubmit(handleClose) {
+    const [launchError, setLaunchError] = useState();
+    return {
+        launchError,
+        submit: (launch) => {
+            try {
+                setLaunchError(undefined);
+                launch();
+                handleClose();
+            }
+            catch (e) {
+                console.error(e);
+                setLaunchError(e);
+            }
+        },
+    };
+}

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.js

@@ -1,14 +1,11 @@
 import { getUngappedSequence, parseMSA } from 'msa-parsers';
+import { cleanProteinSequence } from './util';
 /**
- * A stop codon is present in the transcript's translation and absent from
- * anything an aligner returns, and case is not meaningful in either.
+ * The translation as a search launch would have sent it, so a row that launch
+ * built matches exactly; case means nothing on either side.
  */
 function normalize(seq) {
-    return seq
-        .replaceAll('*', '')
-        .replaceAll('-', '')
-        .replaceAll('.', '')
-        .toUpperCase();
+    return cleanProteinSequence(seq).toUpperCase();
 }
 function identityOverOverlap(a, b) {
     const len = Math.min(a.length, b.length);

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) => {

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,6 +6,18 @@
  * 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[];

package/dist/LaunchMsaView/useQueryRowName.js

@@ -8,6 +8,17 @@ 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

package/dist/LaunchMsaView/useQueryRowName.test.js

@@ -1,7 +1,7 @@
 // @vitest-environment jsdom
 import { act, renderHook } from '@testing-library/react';
 import { describe, expect, test } from 'vitest';
-import { useQueryRowName } from './useQueryRowName';
+import { resolveQueryRowName, useQueryRowName } from './useQueryRowName';
 const protein = 'MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFD';
 const trimmed = `>aligned_query\n${protein.slice(5, 45)}\n>other\nWRONGWRONGWRONGWRONGWRONGWRONGWRONGWRONG\n`;
 describe('useQueryRowName', () => {
@@ -21,3 +21,20 @@ describe('useQueryRowName', () => {
         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.d.ts

@@ -13,5 +13,11 @@ export declare function getTranscriptDisplayName(val?: Feature): string;
 export declare function getGeneDisplayName(val?: Feature): string;
 export declare function getBlastViewTitle(feature: Feature, transcript: Feature): string;
 export declare function getSortedTranscriptFeatures(feature: Feature): Feature[];
+/**
+ * A translation as a query, still one residue per codon: g2p numbers codons,
+ * and the query row is read through it. So the partial first codon (`&`), an
+ * internal stop and an unreadable codon become X, and only what trails the
+ * last whole codon is dropped.
+ */
 export declare function cleanProteinSequence(seq: string): string;
 export declare function getGeneIdentifiers(feature: Feature): string[];