jbrowse-plugin-msaview 2.9.0 → 2.10.1

package/dist/LaunchMsaView/components/BlastQuery/useCachedBlastResults.d.ts

@@ -1,6 +1,6 @@
 export declare function useCachedBlastResults(geneIds: string[]): {
     results: import("../../../utils/blastCache").CachedBlastResult[];
-    error: any;
+    error: unknown;
     isLoading: boolean;
     handleDelete: (id: string) => Promise<void>;
     handleClearAll: () => Promise<void>;

package/dist/LaunchMsaView/components/BlastQuery/useCachedBlastResults.js

@@ -1,27 +1,24 @@
-import useSWR from 'swr';
 import { deleteCachedResult, getAllCachedResults, } from '../../../utils/blastCache';
-import { staticSwrConfig } from '../../../utils/swrConfig';
+import { useFetch } from '../../../utils/useFetch';
 export function useCachedBlastResults(geneIds) {
-    const { data: results, error, isLoading, mutate, } = useSWR(`cached-blast-${geneIds.join(',')}`, async () => {
+    const { data: results, error, isLoading, mutate, } = useFetch(`cached-blast-${geneIds.join(',')}`, async () => {
         const cached = await getAllCachedResults();
         return cached.filter(r => r.geneId && geneIds.includes(r.geneId));
-    }, staticSwrConfig);
-    const handleDelete = async (id) => {
-        await deleteCachedResult(id);
-        await mutate(results => results?.filter(result => result.id !== id) ?? [], false);
-    };
-    // deletes only what this hook listed, i.e. the results for these gene ids.
-    // The list the user is looking at is gene-scoped, so a store-wide clear here
-    // would silently throw away every other gene's cached alignments too
-    const handleClearAll = async () => {
-        await Promise.all((results ?? []).map(r => deleteCachedResult(r.id)));
-        await mutate([], false);
-    };
+    });
     return {
         results: results ?? [],
         error,
         isLoading,
-        handleDelete,
-        handleClearAll,
+        handleDelete: async (id) => {
+            await deleteCachedResult(id);
+            mutate();
+        },
+        // deletes only what this hook listed, i.e. the results for these gene ids.
+        // The list the user is looking at is gene-scoped, so a store-wide clear here
+        // would silently throw away every other gene's cached alignments too
+        handleClearAll: async () => {
+            await Promise.all((results ?? []).map(r => deleteCachedResult(r.id)));
+            mutate();
+        },
     };
 }

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -1,10 +1,11 @@
 import React, { useMemo, useState } from 'react';
-import { Checkbox, FormControlLabel, MenuItem, Typography } from '@mui/material';
+import { Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
+import QuerySpeciesSelect from './QuerySpeciesSelect';
 import { orthologLaunchView } from './orthologLaunchView';
 import TextField2 from '../../../components/TextField2';
-import { COMMON_SPECIES } from '../../../utils/ncbiOrthologs';
+import { defaultMaxSpecies } from '../../../utils/ncbiOrthologs';
 import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
 import MsaAlgorithmSelect from '../BlastQuery/MsaAlgorithmSelect';
 import LaunchPanelContent from '../LaunchPanelContent';
@@ -15,23 +16,6 @@ const useStyles = makeStyles()({
     selectField: {
         width: 180,
     },
-    // A GRID, not a wrapping flex row of fixed-width items. The old form was three
-    // 160px columns inside a 560px box, which is five rows for thirteen species and
-    // eight for twenty-three -- and the checkbox list is the tallest thing in the
-    // dialog, so those rows are the dialog's height. Five auto-fitted columns is
-    // five rows for twenty-three, i.e. more species in less space, and it reflows
-    // rather than being pinned to a width the dialog may not have.
-    speciesBox: {
-        display: 'grid',
-        gridTemplateColumns: 'repeat(auto-fit, minmax(130px, 1fr))',
-        maxWidth: 700,
-        marginTop: 4,
-    },
-    // The label carries the row height; the default control padding is what makes
-    // 23 rows of it tall.
-    species: {
-        marginRight: 0,
-    },
 });
 const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const { classes } = useStyles();
@@ -39,28 +23,24 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
     const [launchViewError, setLaunchViewError] = useState();
     const [taxId, setTaxId] = useState(9606);
     const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
-    const [excluded, setExcluded] = useState([]);
+    const [maxSpecies, setMaxSpecies] = useState(String(defaultMaxSpecies));
     const geneCandidates = useMemo(() => getGeneIdentifiers(feature), [feature]);
     const transcriptSelection = useTranscriptSelection({ feature, view });
     const { selectedTranscript, proteinSequence } = transcriptSelection;
     const e = transcriptSelection.error ?? launchViewError;
-    const taxa = COMMON_SPECIES.map(s => s.taxId).filter(t => !excluded.includes(t));
+    const rowCount = Number(maxSpecies);
+    const rowCountValid = Number.isInteger(rowCount) && rowCount >= 2;
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
-            React.createElement(Typography, { variant: "body2" }, "NCBI's precomputed orthologs, one gene per species, aligned at EBI in seconds rather than the 10+ minutes BLAST takes."),
+            React.createElement(Typography, { variant: "body2" }, "NCBI's precomputed orthologs, one gene per species, looked up rather than searched for. No BLAST job to queue."),
             React.createElement("div", null,
-                React.createElement(TextField2, { variant: "outlined", label: "Query species", className: classes.selectField, select: true, value: taxId, onChange: event => {
-                        setTaxId(Number(event.target.value));
-                    }, helperText: "the species this gene is from" }, COMMON_SPECIES.map(s => (React.createElement(MenuItem, { value: s.taxId, key: s.taxId }, s.label)))),
-                React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: msaAlgorithm, onChange: setMsaAlgorithm })),
-            React.createElement(Typography, { variant: "subtitle2", style: { marginTop: 8 } }, "Species to include (those without an ortholog are skipped)"),
-            React.createElement("div", { className: classes.speciesBox }, COMMON_SPECIES.map(s => (React.createElement(FormControlLabel, { className: classes.species, key: s.taxId, control: React.createElement(Checkbox, { checked: !excluded.includes(s.taxId), onChange: event => {
-                        setExcluded(event.target.checked
-                            ? excluded.filter(t => t !== s.taxId)
-                            : [...excluded, s.taxId]);
-                    } }), label: s.label })))),
+                React.createElement(QuerySpeciesSelect, { className: classes.selectField, value: taxId, assemblyName: view.assemblyNames[0], onChange: setTaxId }),
+                React.createElement(MsaAlgorithmSelect, { className: classes.selectField, value: msaAlgorithm, onChange: setMsaAlgorithm }),
+                React.createElement(TextField2, { variant: "outlined", label: "Rows to align", className: classes.selectField, type: "number", value: maxSpecies, onChange: event => {
+                        setMaxSpecies(event.target.value);
+                    }, error: !rowCountValid, helperText: "the closest N species NCBI has" })),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection })),
-        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || taxa.length < 2, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || !rowCountValid, onSubmit: () => {
                 try {
                     if (selectedTranscript) {
                         setLaunchViewError(undefined);
@@ -70,7 +50,7 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
                             newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
                             orthologParams: {
                                 taxId,
-                                taxa,
+                                maxSpecies: rowCount,
                                 geneCandidates,
                                 msaAlgorithm,
                                 selectedTranscript,

package/dist/LaunchMsaView/components/OrthologQuery/QuerySpeciesSelect.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+/**
+ * The species the query gene came from, as free text resolved against NCBI's
+ * taxonomy rather than picked from a fixed list.
+ *
+ * The resolved taxon is shown back as helper text, which is the whole point of
+ * resolving on a debounce instead of on submit: a typo resolves to some other
+ * organism rather than to nothing, and the only place that surfaces is the gene
+ * lookup, as "could not resolve NLRP1 in taxon 9986".
+ */
+export default function QuerySpeciesSelect({ value, assemblyName, onChange, className, }: {
+    value: number;
+    assemblyName?: string;
+    onChange: (taxId: number) => void;
+    className?: string;
+}): React.JSX.Element;

package/dist/LaunchMsaView/components/OrthologQuery/QuerySpeciesSelect.js

@@ -0,0 +1,65 @@
+import React, { useState } from 'react';
+import TextField2 from '../../../components/TextField2';
+import { resolveAssemblySpecies, resolveTaxId, } from '../../../utils/ncbiTaxonomy';
+import { fetchTaxonomyInfo } from '../../../utils/taxonomyNames';
+import { useDebounced, useFetch } from '../../../utils/useFetch';
+async function describeTaxon(query) {
+    const taxId = await resolveTaxId(query);
+    if (!taxId) {
+        throw new Error(`No NCBI taxon matches "${query}"`);
+    }
+    const info = (await fetchTaxonomyInfo([taxId])).get(taxId);
+    const label = [info?.sciname, info?.commonName && `(${info.commonName})`]
+        .filter(Boolean)
+        .join(' ');
+    return { taxId, label: label || `taxon ${taxId}` };
+}
+/**
+ * The species the query gene came from, as free text resolved against NCBI's
+ * taxonomy rather than picked from a fixed list.
+ *
+ * The resolved taxon is shown back as helper text, which is the whole point of
+ * resolving on a debounce instead of on submit: a typo resolves to some other
+ * organism rather than to nothing, and the only place that surfaces is the gene
+ * lookup, as "could not resolve NLRP1 in taxon 9986".
+ */
+export default function QuerySpeciesSelect({ value, assemblyName, onChange, className, }) {
+    // undefined until the user types, which is what makes the two lookups
+    // exclusive rather than both firing on open
+    const [typed, setTyped] = useState();
+    const debounced = useDebounced(typed, 400);
+    // Opening on `human` for everyone is the same silent wrong answer the fixed
+    // species list gave: on a mouse assembly the gene symbol resolves to the HUMAN
+    // gene, and the excluded taxon is human too, so mouse appears twice. The
+    // assembly being browsed is the one thing here that already knows the answer.
+    //
+    // db=assembly already returns the taxon id, so this is the whole lookup — the
+    // taxonomy chain below would be two more requests for an answer we hold. That
+    // is not just waste: eutils allows 3 requests a second and throttles by
+    // answering without CORS headers, so all four fired on open and the browser
+    // reported the throttle as "blocked by CORS policy" in the helper text.
+    const { data: fromAssembly } = useFetch(assemblyName && typed === undefined
+        ? [assemblyName, 'assembly-species']
+        : null, () => resolveAssemblySpecies(assemblyName), {
+        onSuccess: found => {
+            if (found) {
+                onChange(found.taxId);
+            }
+        },
+    });
+    const { data: fromText, error } = useFetch(debounced?.trim() ? [debounced.trim(), 'taxon'] : null, () => describeTaxon(debounced), {
+        onSuccess: ({ taxId }) => {
+            onChange(taxId);
+        },
+    });
+    // derived, not seeded through an effect: whatever the user typed wins, and
+    // until they type anything the assembly's species does, so a lookup that
+    // lands while they are mid-word cannot overwrite the field
+    const text = typed ?? fromAssembly?.speciesName ?? 'human';
+    const resolved = typed === undefined ? fromAssembly?.speciesName : fromText?.label;
+    return (React.createElement(TextField2, { variant: "outlined", label: "Query species", className: className, value: text, onChange: event => {
+            setTyped(event.target.value);
+        }, error: !!error, helperText: error
+            ? `${error}`
+            : (resolved ?? `the species this gene is from (taxon ${value})`) }));
+}

package/dist/LaunchMsaView/components/PreLoadedMSA/PreLoadedMSADataPanel.js

@@ -3,10 +3,9 @@ import { LoadingEllipses, SanitizedHTML } from '@jbrowse/core/ui';
 import { getEnv, getSession } from '@jbrowse/core/util';
 import { MenuItem } from '@mui/material';
 import { observer } from 'mobx-react';
-import useSWR from 'swr';
 import { makeStyles } from 'tss-react/mui';
 import TextField2 from '../../../components/TextField2';
-import { staticSwrConfig } from '../../../utils/swrConfig';
+import { useFetch } from '../../../utils/useFetch';
 import { getGeneDisplayName, getLinearGenomeView } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
 import SubmitCancelActions from '../SubmitCancelActions';
@@ -30,20 +29,20 @@ const PreLoadedMSA = observer(function ({ model, feature, handleClose, }) {
     const datasets = readMsaDatasets(session.jbrowse);
     const [selectedDatasetId, setSelectedDatasetId] = useState(datasets?.[0]?.datasetId);
     const selectedDataset = datasets?.find(d => d.datasetId === selectedDatasetId);
-    const { data: msaList, isLoading: msaListLoading, error: msaListFetchError, } = useSWR(selectedDataset ? `${selectedDataset.datasetId}-msa-list` : null, () => fetchMSAList({ config: selectedDataset.adapter, pluginManager }), staticSwrConfig);
+    const { data: msaList, isLoading: msaListLoading, error: msaListFetchError, } = useFetch(selectedDataset ? `${selectedDataset.datasetId}-msa-list` : null, () => fetchMSAList({ config: selectedDataset.adapter, pluginManager }));
     const transcriptSelection = useTranscriptSelection({
         feature,
         view,
         validIds: msaList,
     });
     const { selectedId, selectedTranscript } = transcriptSelection;
-    const { data: msaData, isLoading: msaDataLoading, error: msaDataFetchError, } = useSWR(selectedId && selectedDataset && msaList
+    const { data: msaData, isLoading: msaDataLoading, error: msaDataFetchError, } = useFetch(selectedId && selectedDataset && msaList
         ? `${selectedDataset.datasetId}-${selectedId}-msa`
         : null, () => fetchMSA({
         msaId: selectedId,
         config: selectedDataset.adapter,
         pluginManager,
-    }), staticSwrConfig);
+    }));
     const e = msaListFetchError ??
         msaDataFetchError ??
         transcriptSelection.error ??

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

@@ -1,13 +1,15 @@
 import type { Feature } from '@jbrowse/core/util';
+interface ViewLike {
+    assemblyNames?: string[];
+}
 export declare function useFeatureSequence({ view, feature, }: {
-    view: {
-        assemblyNames?: string[];
-    } | undefined;
+    view: ViewLike | undefined;
     feature?: Feature;
 }): {
     proteinSequence: string;
     sequence: {
         seq: string;
     } | undefined;
-    error: any;
+    error: unknown;
 };
+export {};

package/dist/LaunchMsaView/components/useFeatureSequence.js

@@ -1,18 +1,27 @@
+import { getSession } from '@jbrowse/core/util';
 import { getProteinSequenceFromFeature } from './calculateProteinSequence';
-import { useSWRFeatureSequence } from './useSWRFeatureSequence';
+import { fetchSeq } from './fetchSeq';
+import { useFetch } from '../../utils/useFetch';
 export function useFeatureSequence({ view, feature, }) {
-    const { sequence, error } = useSWRFeatureSequence({
-        view,
-        feature,
+    const assemblyName = view?.assemblyNames?.[0];
+    const { data: sequence, error } = 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),
+            }),
+        };
     });
-    const proteinSequence = sequence && feature
-        ? getProteinSequenceFromFeature({
-            seq: sequence.seq,
-            feature,
-        })
-        : '';
     return {
-        proteinSequence,
+        proteinSequence: sequence && feature
+            ? getProteinSequenceFromFeature({ seq: sequence.seq, feature })
+            : '',
         sequence,
         error,
     };

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

@@ -11,6 +11,6 @@ export declare function useTranscriptSelection({ feature, view, validIds, }: {
     setSelectedId: import("react").Dispatch<import("react").SetStateAction<string>>;
     selectedTranscript: Feature | undefined;
     proteinSequence: string;
-    error: any;
+    error: unknown;
     validIds: string[] | undefined;
 };

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

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

package/dist/LaunchMsaView/extendStateModel.test.js

@@ -0,0 +1,69 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { describe, expect, test } from 'vitest';
+import { extendStateModel } from './index';
+// A host display whose own contextMenuItems reaches the rest of itself through
+// `this` -- which is what jbrowse-components shipped between b439251a21 and
+// 104bbfc581, and what any host is free to do again. This plugin captures the
+// base method and calls it detached, so a bare call leaves `this` undefined, the
+// read throws inside the ErrorBoundary the menu builds in, and a right-click
+// produces no menu at all: the host's own rows go with it.
+function hostReadingThis(clickedType) {
+    return types
+        .model('MockDisplay', { id: types.optional(types.string, 'display1') })
+        .views(self => ({
+        get isGeneLike() {
+            return self.id === 'display1';
+        },
+    }))
+        .views(() => ({
+        contextMenuItems() {
+            return [{ label: `host item ${this.isGeneLike}` }];
+        },
+        get contextMenuInfo() {
+            return {
+                item: { featureId: 'f1', type: clickedType },
+                displayedRegionIndex: 0,
+            };
+        },
+        fetchFullFeature() {
+            return Promise.resolve(undefined);
+        },
+    }));
+}
+const labels = (stateModel) => stateModel
+    .create()
+    .contextMenuItems()
+    .map((i) => i.label);
+describe('extendStateModel', () => {
+    test('calls the host contextMenuItems with a receiver', () => {
+        expect(labels(extendStateModel(hostReadingThis('mRNA')))).toEqual([
+            'host item true',
+            'Launch MSA view',
+        ]);
+    });
+    test('leaves the host menu alone when the click is not on a gene', () => {
+        expect(labels(extendStateModel(hostReadingThis('CDS')))).toEqual([
+            'host item true',
+        ]);
+    });
+    // two plugins extending the same display each capture the previous
+    // contextMenuItems, so the receiver has to survive the whole chain
+    test('survives another plugin extending the display underneath it', () => {
+        const withOther = extendStateModel(hostReadingThis('mRNA')).views(self => {
+            const superContextMenuItems = self.contextMenuItems;
+            return {
+                contextMenuItems() {
+                    return [
+                        ...superContextMenuItems.call(self),
+                        { label: 'other plugin' },
+                    ];
+                },
+            };
+        });
+        expect(labels(withOther)).toEqual([
+            'host item true',
+            'Launch MSA view',
+            'other plugin',
+        ]);
+    });
+});

package/dist/LaunchMsaView/index.d.ts

@@ -1,2 +1,4 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
+import type { IAnyModelType } from '@jbrowse/mobx-state-tree';
+export declare function extendStateModel(stateModel: IAnyModelType): import("@jbrowse/mobx-state-tree").IModelType<any, any, any, any>;
 export default function LaunchMsaViewF(pluginManager: PluginManager): void;

package/dist/LaunchMsaView/index.js

@@ -1,51 +1,59 @@
 import { getContainingTrack, getSession } from '@jbrowse/core/util';
 import AddIcon from '@mui/icons-material/Add';
 import LaunchMsaViewDialog from './components/LaunchMsaViewDialog';
+import { launchTarget } from './launchTarget';
 function isDisplay(elt) {
     return elt.name === 'LinearBasicDisplay';
 }
-const GENE_LIKE_TYPES = new Set(['gene', 'mRNA', 'transcript']);
-function extendStateModel(stateModel) {
+// Walking to the track and the session at click time, not while the menu is
+// 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) {
+    const track = getContainingTrack(self);
+    const session = getSession(track);
+    feature()
+        .then(f => {
+        if (f) {
+            session.queueDialog(handleClose => [
+                LaunchMsaViewDialog,
+                { model: track, handleClose, feature: f },
+            ]);
+        }
+        else {
+            session.notify('Could not load feature for MSA view', 'warning');
+        }
+    })
+        .catch((e) => {
+        session.notifyError(`${e}`, e);
+    });
+}
+export function extendStateModel(stateModel) {
     return stateModel.views((self) => {
         const superContextMenuItems = self.contextMenuItems;
         return {
             contextMenuItems() {
-                const track = getContainingTrack(self);
-                const session = getSession(track);
-                const launch = (feature) => {
-                    session.queueDialog(handleClose => [
-                        LaunchMsaViewDialog,
-                        { model: track, handleClose, feature },
-                    ]);
-                };
-                const info = self.contextMenuInfo;
-                const fetchFullFeature = self.fetchFullFeature;
-                const legacyFeature = self.contextMenuFeature;
-                const onClick = info && fetchFullFeature && self.isGeneLike
-                    ? () => {
-                        fetchFullFeature(info.item.featureId, info.displayedRegionIndex)
-                            .then(feature => {
-                            if (feature) {
-                                launch(feature);
-                            }
-                            else {
-                                session.notify('Could not load feature for MSA view', 'warning');
-                            }
-                        })
-                            .catch((e) => {
-                            session.notifyError(`${e}`, e);
-                        });
-                    }
-                    : legacyFeature &&
-                        GENE_LIKE_TYPES.has(String(legacyFeature.get('type')))
-                        ? () => {
-                            launch(legacyFeature);
-                        }
-                        : undefined;
+                const target = launchTarget(self);
                 return [
-                    ...superContextMenuItems(),
-                    ...(onClick
-                        ? [{ label: 'Launch MSA view', icon: AddIcon, onClick }]
+                    // .call(self), not a bare call: a host's own contextMenuItems may
+                    // reach its sibling views through `this`, which is undefined when the
+                    // captured super is invoked detached. It throws, the ErrorBoundary the
+                    // menu builds inside swallows it, and the user right-clicks a feature
+                    // and gets no menu at all -- the host's own rows gone too, which is
+                    // worse than this plugin contributing nothing. jbrowse-components hit
+                    // exactly this with `this.isGeneLike` and fixed its side in
+                    // 104bbfc581, but a plugin cannot choose which host build it runs on.
+                    ...superContextMenuItems.call(self),
+                    ...(target
+                        ? [
+                            {
+                                label: 'Launch MSA view',
+                                icon: AddIcon,
+                                onClick: () => {
+                                    openDialog(self, target);
+                                },
+                            },
+                        ]
                         : []),
                 ];
             },

package/dist/LaunchMsaView/launchTarget.d.ts

@@ -0,0 +1,25 @@
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { Feature } from '@jbrowse/core/util';
+export interface ContextMenuInfo {
+    item: {
+        featureId: string;
+        type?: string;
+    };
+    displayedRegionIndex: number;
+}
+export interface DisplayModel {
+    contextMenuItems: () => MenuItem[];
+    contextMenuInfo?: ContextMenuInfo;
+    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.
+ */
+export declare function launchTarget(self: DisplayModel): (() => Promise<Feature | undefined>) | undefined;

package/dist/LaunchMsaView/launchTarget.js

@@ -0,0 +1,42 @@
+// Read off the clicked item rather than off the display.
+//
+// LinearBasicDisplay used to publish an `isGeneLike` getter and this gated on
+// it. jbrowse-components 684142b3 (2026-08-16) inlined that getter into its own
+// `contextMenuItems`, and every host built after it returns `undefined` here --
+// so the gate was never satisfied, `onClick` stayed undefined, and the item
+// silently left the right-click menu on every gene track. Nothing failed loudly:
+// the display still had contextMenuInfo and fetchFullFeature, and the menu still
+// opened with its own items in it.
+//
+// A predicate over the type we were already given cannot go the same way, and it
+// 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');
+}
+/**
+ * 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.
+ */
+export function launchTarget(self) {
+    const info = self.contextMenuInfo;
+    const fetchFullFeature = self.fetchFullFeature;
+    // exclusive, not a fallthrough: a display publishing contextMenuInfo has
+    // already said what was clicked, and reading contextMenuFeature after it
+    // rejects the click can only answer with some other feature
+    if (info && fetchFullFeature) {
+        return isGeneLikeType(info.item.type)
+            ? () => fetchFullFeature(info.item.featureId, info.displayedRegionIndex)
+            : undefined;
+    }
+    const legacy = self.contextMenuFeature;
+    return legacy && isGeneLikeType(legacy.get('type'))
+        ? () => Promise.resolve(legacy)
+        : undefined;
+}

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

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

package/dist/LaunchMsaView/launchTarget.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vitest';
+import { isGeneLikeType, launchTarget } from './launchTarget';
+function feature(type) {
+    return {
+        get: (key) => (key === 'type' ? type : undefined),
+    };
+}
+const modernHost = (type) => ({
+    contextMenuItems: () => [],
+    contextMenuInfo: { item: { featureId: 'f1', type }, displayedRegionIndex: 0 },
+    fetchFullFeature: (featureId) => Promise.resolve(feature(`fetched:${featureId}`)),
+});
+const legacyHost = (type) => ({
+    contextMenuItems: () => [],
+    contextMenuFeature: feature(type),
+});
+describe('isGeneLikeType', () => {
+    test.each(['gene', 'mRNA', 'transcript', 'lnc_RNA', 'protein_coding_gene'])('accepts %s', type => {
+        expect(isGeneLikeType(type)).toBe(true);
+    });
+    test.each(['CDS', 'exon', 'match', 'SNV', undefined, null, 42])('rejects %s', type => {
+        expect(isGeneLikeType(type)).toBe(false);
+    });
+});
+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');
+    });
+    test('offers nothing for a non-gene click', () => {
+        expect(launchTarget(modernHost('CDS'))).toBeUndefined();
+        expect(launchTarget(modernHost(undefined))).toBeUndefined();
+    });
+    test('offers nothing when nothing was clicked', () => {
+        expect(launchTarget({ contextMenuItems: () => [] })).toBeUndefined();
+    });
+    // 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('applies the same gene test on both host shapes', () => {
+        expect(launchTarget(legacyHost('lnc_RNA'))).toBeDefined();
+        expect(launchTarget(legacyHost('exon'))).toBeUndefined();
+    });
+    // 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();
+    });
+});