jbrowse-plugin-msaview 2.7.2 → 2.7.4

package/dist/AddHighlightModel/MsaToGenomeHighlight.js

@@ -11,11 +11,12 @@ const MsaToGenomeHighlight = observer(function MsaToGenomeHighlight2({ model, })
     // The persistent click selection always shows. The hover codon is suppressed
     // while hovering the LGV — GenomeMouseoverHighlight handles the single-bp
     // display in that case, so we don't stack a wider codon band on top of it.
-    const clickHighlight = msaView?.connectedClickHighlight;
-    const hoverHighlight = hasHoverPosition(hovered)
-        ? undefined
-        : msaView?.connectedHoverHighlight;
-    const highlights = [clickHighlight, hoverHighlight].filter((r) => r !== undefined);
+    const highlights = [
+        ...(msaView?.connectedClickHighlights ?? []),
+        ...(hasHoverPosition(hovered)
+            ? []
+            : (msaView?.connectedHoverHighlights ?? [])),
+    ];
     return highlights.length ? (React.createElement(MsaToGenomeHighlightRenderer, { model: model, highlights: highlights })) : null;
 });
 // Inner component: handles the scroll-dependent rendering

package/dist/LaunchMsaView/components/LaunchMsaViewDialog.js

@@ -4,6 +4,7 @@ import { getSession } from '@jbrowse/core/util';
 import { Tab, Tabs } from '@mui/material';
 import ManualMSALoader from './ManualMSALoader/ManualMSALoader';
 import NCBIBlastPanel from './NCBIBlastQuery/NCBIBlastPanel';
+import OrthologPanel from './OrthologQuery/OrthologPanel';
 import PreLoadedMSA from './PreLoadedMSA/PreLoadedMSADataPanel';
 import { readMsaDatasets } from './PreLoadedMSA/types';
 import TabPanel from './TabPanel';
@@ -11,14 +12,19 @@ export default function LaunchMsaViewDialog({ handleClose, feature, model, }) {
     const session = getSession(model);
     const datasets = readMsaDatasets(session.jbrowse);
     const hasPreloadedDatasets = !!datasets?.length;
-    const [value, setValue] = useState('ncbi_blast');
+    // orthologs first, and the default: it answers the same question in ~10s
+    // that BLAST takes 10+ minutes to answer worse (see utils/ncbiOrthologs.ts)
+    const [value, setValue] = useState('orthologs');
     return (React.createElement(Dialog, { maxWidth: "xl", title: "Launch MSA view", open: true, onClose: handleClose },
         React.createElement(Tabs, { value: value, onChange: (_event, newValue) => {
                 setValue(newValue);
             } },
+            React.createElement(Tab, { label: "Orthologs (fast)", value: "orthologs" }),
             React.createElement(Tab, { label: "NCBI BLAST query", value: "ncbi_blast" }),
             hasPreloadedDatasets ? (React.createElement(Tab, { label: "Pre-loaded MSA datasets", value: "preloaded_msa" })) : null,
             React.createElement(Tab, { label: "Manual upload", value: "manual_msa" })),
+        React.createElement(TabPanel, { value: value, index: "orthologs" },
+            React.createElement(OrthologPanel, { handleClose: handleClose, feature: feature, model: model })),
         React.createElement(TabPanel, { value: value, index: "ncbi_blast" },
             React.createElement(NCBIBlastPanel, { handleClose: handleClose, feature: feature, model: model })),
         hasPreloadedDatasets ? (React.createElement(TabPanel, { value: value, index: "preloaded_msa" },

package/dist/LaunchMsaView/components/NCBIBlastQuery/CachedBlastResults.js

@@ -68,7 +68,7 @@ const CachedBlastResults = observer(function ({ model, handleClose, feature, })
                     catch (e) {
                         setOperationError(e);
                     }
-                } }, "Clear All")),
+                } }, "Clear results for this gene")),
         React.createElement(List, { dense: true, className: classes.resultList }, results.map(result => (React.createElement(ListItem, { key: result.id, disablePadding: true, secondaryAction: React.createElement(IconButton, { edge: "end", size: "small", onClick: async (e) => {
                     e.stopPropagation();
                     try {

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

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

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

@@ -1,5 +1,5 @@
 import useSWR from 'swr';
-import { clearAllCachedResults, deleteCachedResult, getAllCachedResults, } from '../../../utils/blastCache';
+import { deleteCachedResult, getAllCachedResults, } from '../../../utils/blastCache';
 import { staticSwrConfig } from '../../../utils/swrConfig';
 export function useCachedBlastResults(geneIds) {
     const { data: results, error, isLoading, mutate, } = useSWR(`cached-blast-${geneIds.join(',')}`, async () => {
@@ -10,8 +10,11 @@ export function useCachedBlastResults(geneIds) {
         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 clearAllCachedResults();
+        await Promise.all((results ?? []).map(r => deleteCachedResult(r.id)));
         await mutate([], false);
     };
     return {

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
+declare const OrthologPanel: ({ handleClose, feature, model, }: {
+    model: AbstractTrackModel;
+    feature: Feature;
+    handleClose: () => void;
+}) => React.JSX.Element;
+export default OrthologPanel;

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

@@ -0,0 +1,86 @@
+import React, { useMemo, useState } from 'react';
+import { Checkbox, FormControlLabel, MenuItem, Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
+import { orthologLaunchView } from './orthologLaunchView';
+import TextField2 from '../../../components/TextField2';
+import { COMMON_SPECIES } from '../../../utils/ncbiOrthologs';
+import { getGeneDisplayName, getGeneIdentifiers, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
+import LaunchPanelContent from '../LaunchPanelContent';
+import MsaAlgorithmSelect from '../NCBIBlastQuery/MsaAlgorithmSelect';
+import SubmitCancelActions from '../SubmitCancelActions';
+import TranscriptSelector from '../TranscriptSelector';
+import { useTranscriptSelection } from '../useTranscriptSelection';
+const useStyles = makeStyles()({
+    selectField: {
+        width: 180,
+    },
+    speciesBox: {
+        display: 'flex',
+        flexWrap: 'wrap',
+        maxWidth: 560,
+        marginTop: 12,
+    },
+    species: {
+        width: 160,
+    },
+    infoText: {
+        marginTop: 20,
+        maxWidth: 620,
+    },
+});
+const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
+    const { classes } = useStyles();
+    const view = getLinearGenomeView(model);
+    const [launchViewError, setLaunchViewError] = useState();
+    const [taxId, setTaxId] = useState(9606);
+    const [msaAlgorithm, setMsaAlgorithm] = useState('clustalo');
+    const [excluded, setExcluded] = useState([]);
+    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));
+    return (React.createElement(React.Fragment, null,
+        React.createElement(LaunchPanelContent, { error: e },
+            React.createElement(Typography, null, "Builds the alignment from NCBI's precomputed orthologs \u2014 one gene per species \u2014 instead of searching. There is no job to wait on: the NCBI lookups take about a second, and only the multiple alignment at EBI costs real time (~10s), against 10+ minutes for BLAST. Rows come out labelled by species rather than by accession, and NCBI's CDD domains are overlaid automatically."),
+            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: 12 } }, "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(TranscriptSelector, { feature: feature, ...transcriptSelection }),
+            React.createElement(Typography, { className: classes.infoText, variant: "body2" }, "The query row is the transcript selected above, not NCBI's representative protein, so the alignment stays linked to the genome view at codon resolution.")),
+        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || taxa.length < 2, onSubmit: () => {
+                try {
+                    if (selectedTranscript) {
+                        setLaunchViewError(undefined);
+                        orthologLaunchView({
+                            feature: selectedTranscript,
+                            view,
+                            newViewTitle: `Orthologs - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
+                            orthologParams: {
+                                taxId,
+                                taxa,
+                                geneCandidates,
+                                msaAlgorithm,
+                                selectedTranscript,
+                                proteinSequence,
+                            },
+                        });
+                        handleClose();
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    setLaunchViewError(e);
+                }
+            }, onCancel: handleClose })));
+});
+export default OrthologPanel;

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

@@ -0,0 +1,9 @@
+import type { OrthologParams } from '../../../MsaViewPanel/model';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+export declare function orthologLaunchView({ newViewTitle, view, feature, orthologParams, }: {
+    newViewTitle: string;
+    view: LinearGenomeViewModel;
+    feature: Feature;
+    orthologParams: OrthologParams;
+}): void;

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

@@ -0,0 +1,13 @@
+import { getSession } from '@jbrowse/core/util';
+export function orthologLaunchView({ newViewTitle, view, feature, orthologParams, }) {
+    getSession(view).addView('MsaView', {
+        type: 'MsaView',
+        displayName: newViewTitle,
+        connectedViewId: view.id,
+        connectedFeature: feature.toJSON(),
+        drawNodeBubbles: true,
+        colWidth: 10,
+        rowHeight: 12,
+        orthologParams,
+    });
+}

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -1,6 +1,14 @@
 import type { JBrowsePluginMsaViewModel } from './model';
 export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
 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.
+ */
+export declare function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel): void;
 export declare function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel): void;
 /**
  * Once an accession-bearing alignment is present (fresh from BLAST or restored

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -1,5 +1,6 @@
 import { getSession } from '@jbrowse/core/util';
 import { doLaunchBlast } from './doLaunchBlast';
+import { doLaunchOrthologs } from './doLaunchOrthologs';
 import { fetchIndexedMsa } from './fetchIndexedMsa';
 import { genomeToMSA } from './genomeToMSA';
 import { loadProteinDomains } from './loadProteinDomains';
@@ -69,6 +70,33 @@ 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.
+ */
+export function launchOrthologsIfNeeded(self) {
+    if (self.orthologParams) {
+        void (async () => {
+            try {
+                self.setProgress('Resolving orthologs');
+                self.setError(undefined);
+                const data = await doLaunchOrthologs({ self });
+                self.setData(data);
+                self.setOrthologParams(undefined);
+            }
+            catch (e) {
+                self.setError(e);
+                console.error(e);
+            }
+            finally {
+                self.setProgress('');
+            }
+        })();
+    }
+}
 export function launchBlastIfNeeded(self) {
     if (self.blastParams) {
         void (async () => {

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -7,36 +7,26 @@ import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 export async function doLaunchBlast({ self, }) {
     const { baseUrl, blastDatabase, blastProgram, msaAlgorithm, proteinSequence, selectedTranscript, rid: existingRid, } = self.blastParams;
     const cleanedSeq = cleanProteinSequence(proteinSequence);
-    let hits;
-    let rid;
+    const onProgress = (arg) => {
+        self.setProgress(arg);
+    };
     if (existingRid) {
+        // publish it before the first poll so the view can link out to NCBI while
+        // the job is still running
         self.setRid(existingRid);
-        const result = await queryBlastFromRid({
-            rid: existingRid,
-            baseUrl,
-            onProgress: arg => {
-                self.setProgress(arg);
-            },
-        });
-        hits = result.hits;
-        rid = result.rid;
     }
-    else {
-        const result = await queryBlast({
+    const { hits, rid } = existingRid
+        ? await queryBlastFromRid({ rid: existingRid, baseUrl, onProgress })
+        : await queryBlast({
             query: cleanedSeq,
             blastDatabase,
             blastProgram,
             baseUrl,
-            onProgress: arg => {
-                self.setProgress(arg);
-            },
+            onProgress,
             onRid: r => {
                 self.setRid(r);
             },
         });
-        hits = result.hits;
-        rid = result.rid;
-    }
     self.setProgress('Fetching species taxonomy info...');
     const taxids = hits
         .map(h => h.description[0]?.taxid)
@@ -57,9 +47,7 @@ export async function doLaunchBlast({ self, }) {
     const result = await launchMSA({
         algorithm: msaAlgorithm,
         sequence: [`>QUERY\n${cleanedSeq}`, ...sequences].join('\n'),
-        onProgress: arg => {
-            self.setProgress(arg);
-        },
+        onProgress,
     });
     const treeMetadataJson = JSON.stringify(treeMetadata);
     await saveBlastResult({

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -0,0 +1,23 @@
+import type { JBrowsePluginMsaViewModel } from './model';
+/**
+ * The no-search-job alternative to doLaunchBlast.
+ *
+ * BLAST spends 10+ minutes answering "what looks like this sequence" and
+ * returns a redundant, accession-labelled hit list. This asks NCBI the question
+ * the alignment actually wants — "what is this gene's ortholog in each species"
+ * — which NCBI has already computed, so the whole NCBI half returns in about a
+ * second and only the EBI alignment (~10s) costs real time.
+ *
+ * The query row is the user's OWN selected transcript, not NCBI's
+ * representative protein for the query species, because `connectedFeature`
+ * maps genome coordinates through that row — swapping in a different isoform
+ * would silently break the genome<->MSA linkage. The query species is therefore
+ * excluded from the ortholog set rather than appearing twice.
+ */
+export declare function doLaunchOrthologs({ self, }: {
+    self: JBrowsePluginMsaViewModel;
+}): Promise<{
+    treeMetadata: string;
+    msa: string;
+    tree: string;
+}>;

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -0,0 +1,97 @@
+import { cleanProteinSequence } from '../LaunchMsaView/util';
+import { launchMSA } from '../utils/msa';
+import { fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
+/**
+ * The no-search-job alternative to doLaunchBlast.
+ *
+ * BLAST spends 10+ minutes answering "what looks like this sequence" and
+ * returns a redundant, accession-labelled hit list. This asks NCBI the question
+ * the alignment actually wants — "what is this gene's ortholog in each species"
+ * — which NCBI has already computed, so the whole NCBI half returns in about a
+ * second and only the EBI alignment (~10s) costs real time.
+ *
+ * The query row is the user's OWN selected transcript, not NCBI's
+ * representative protein for the query species, because `connectedFeature`
+ * maps genome coordinates through that row — swapping in a different isoform
+ * would silently break the genome<->MSA linkage. The query species is therefore
+ * excluded from the ortholog set rather than appearing twice.
+ */
+export async function doLaunchOrthologs({ self, }) {
+    const { taxId, taxa, geneCandidates, msaAlgorithm, proteinSequence } = self.orthologParams;
+    const cleanedSeq = cleanProteinSequence(proteinSequence);
+    const onProgress = (arg) => {
+        self.setProgress(arg);
+    };
+    onProgress('Resolving gene at NCBI...');
+    const resolved = await resolveGeneId(geneCandidates, taxId);
+    if (!resolved) {
+        throw new Error(`Could not resolve any of ${geneCandidates.join(', ')} to an NCBI gene in taxon ${taxId}. Try the NCBI BLAST tab, which needs no gene identifier.`);
+    }
+    // the query species is represented by the user's own transcript below
+    const wanted = new Set(taxa.filter(t => t !== taxId));
+    const rows = await fetchOrthologRows({
+        geneId: resolved.geneId,
+        taxa: wanted,
+        onProgress,
+    });
+    const treeMetadata = {
+        QUERY: await buildQueryMetadata(self, resolved.geneId, cleanedSeq),
+    };
+    for (const row of rows) {
+        treeMetadata[row.label] = buildRowMetadata(row);
+    }
+    const result = await launchMSA({
+        algorithm: msaAlgorithm,
+        sequence: [
+            `>QUERY\n${cleanedSeq}`,
+            ...rows.map(r => `>${r.label}\n${r.sequence}`),
+        ].join('\n'),
+        onProgress,
+    });
+    return {
+        ...result,
+        treeMetadata: JSON.stringify(treeMetadata),
+    };
+}
+/**
+ * The query row is the user's own translated transcript, so it carries an
+ * Accession — which is what drives the automatic CDD overlay
+ * (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains) — ONLY
+ * when its sequence is byte-identical to the RefSeq protein that accession
+ * names. Attaching it unconditionally would put every domain box at an offset
+ * whenever the user picked a non-representative isoform, which is a silently
+ * wrong figure rather than a missing one.
+ */
+async function buildQueryMetadata(self, geneId, proteinSequence) {
+    const transcript = self.orthologParams?.selectedTranscript;
+    const metadata = { 'Gene ID': geneId };
+    const name = transcript?.get('name') ?? transcript?.get('id');
+    if (name) {
+        metadata.Transcript = name;
+    }
+    try {
+        const representative = await fetchProteinForGene(geneId);
+        if (representative?.sequence === proteinSequence) {
+            metadata.Accession = representative.accession;
+        }
+    }
+    catch (e) {
+        // a failed lookup only costs the query row its domain overlay, so it must
+        // not take down an alignment that is otherwise complete
+        console.warn('[msaview-orthologs] query protein lookup failed:', e);
+    }
+    return metadata;
+}
+function buildRowMetadata(row) {
+    const metadata = {
+        'Scientific name': row.scientificName,
+        // Accession drives the automatic CDD domain overlay
+        // (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains)
+        Accession: row.protein,
+        'Gene ID': row.geneId,
+    };
+    if (row.commonName) {
+        metadata['Common name'] = row.commonName;
+    }
+    return metadata;
+}

package/dist/MsaViewPanel/genomeToMSA.js

@@ -6,18 +6,25 @@ export function genomeToMSA({ model }) {
     if (!connectedView?.initialized || !hasHoverPosition(hovered)) {
         return undefined;
     }
-    const { coord: hoverCoord, refName } = hovered.hoverPosition;
+    const { coord, refName } = hovered.hoverPosition;
+    // hoverPosition.coord is a 1-based display coordinate (core's pxToBp adds the
+    // +1), while g2p and mafRegion are keyed by 0-based genome position
+    const genomePos = coord - 1;
     if (mafRegion) {
         if (refName !== mafRegion.refName ||
             !connectedView.assemblyNames.includes(mafRegion.assemblyName) ||
-            hoverCoord < mafRegion.start ||
-            hoverCoord >= mafRegion.end) {
+            genomePos < mafRegion.start ||
+            genomePos >= mafRegion.end) {
             return undefined;
         }
-        return model.seqPosToVisibleCol(querySeqName, hoverCoord - mafRegion.start);
+        return model.seqPosToVisibleCol(querySeqName, genomePos - mafRegion.start);
     }
-    if (transcriptToMsaMap) {
-        const seqPos = transcriptToMsaMap.g2p[hoverCoord];
+    // session.hovered is global -- set by whichever LinearGenomeView the cursor
+    // was last over, on any assembly -- so the refName gate is load bearing:
+    // without it the same numeric coordinate on an unrelated chromosome matches a
+    // g2p key and lights up a column for a different locus
+    if (refName === transcriptToMsaMap?.refName) {
+        const seqPos = transcriptToMsaMap.g2p[genomePos];
         if (seqPos !== undefined) {
             return model.seqPosToVisibleCol(querySeqName, seqPos);
         }

package/dist/MsaViewPanel/genomeToMSA.test.js

@@ -76,8 +76,9 @@ describe('genomeToMSA', () => {
                 seqPosToVisibleCol: mockSeqPosToVisibleCol,
             };
             const result = genomeToMSA({ model });
-            // coord 1005 - start 1000 = ungapped position 5
-            expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('hg38.chr1', 5);
+            // hover coord 1005 is 1-based, so the 0-based genome position is 1004,
+            // which is ungapped position 4 of a region starting at 1000
+            expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('hg38.chr1', 4);
             expect(result).toBe(5);
         });
         test('returns undefined when hover refName does not match mafRegion', () => {
@@ -106,10 +107,11 @@ describe('genomeToMSA', () => {
             expect(result).toBeUndefined();
         });
         test('returns undefined when hover coord is before mafRegion start', () => {
+            // 1-based coord 1000 is the 0-based base 999, one before the region
             mockGetSession.mockReturnValue({
                 hovered: {
                     hoverFeature: {},
-                    hoverPosition: { coord: 999, refName: 'chr1' },
+                    hoverPosition: { coord: 1000, refName: 'chr1' },
                 },
             });
             const model = {
@@ -131,10 +133,11 @@ describe('genomeToMSA', () => {
             expect(result).toBeUndefined();
         });
         test('returns undefined when hover coord is at or after mafRegion end', () => {
+            // 1-based coord 1011 is the 0-based base 1010, one past the region
             mockGetSession.mockReturnValue({
                 hovered: {
                     hoverFeature: {},
-                    hoverPosition: { coord: 1010, refName: 'chr1' },
+                    hoverPosition: { coord: 1011, refName: 'chr1' },
                 },
             });
             const model = {
@@ -193,7 +196,9 @@ describe('genomeToMSA', () => {
             const model = {
                 querySeqName: 'QUERY',
                 transcriptToMsaMap: {
-                    g2p: { 1005: 10 },
+                    refName: 'chr1',
+                    // g2p is keyed by 0-based genome position, the hover coord is 1-based
+                    g2p: { 1004: 10 },
                 },
                 mafRegion: undefined,
                 connectedView: { initialized: true },
@@ -203,6 +208,29 @@ describe('genomeToMSA', () => {
             expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('QUERY', 10);
             expect(result).toBe(10);
         });
+        test('returns undefined when the hover is on another refName', () => {
+            // session.hovered is global, so a hover on an unrelated chromosome can
+            // carry a coordinate that happens to be a g2p key
+            mockGetSession.mockReturnValue({
+                hovered: {
+                    hoverFeature: {},
+                    hoverPosition: { coord: 1005, refName: 'chr2' },
+                },
+            });
+            const mockSeqPosToVisibleCol = vi.fn();
+            const model = {
+                querySeqName: 'QUERY',
+                transcriptToMsaMap: {
+                    refName: 'chr1',
+                    g2p: { 1004: 10 },
+                },
+                mafRegion: undefined,
+                connectedView: { initialized: true },
+                seqPosToVisibleCol: mockSeqPosToVisibleCol,
+            };
+            expect(genomeToMSA({ model })).toBeUndefined();
+            expect(mockSeqPosToVisibleCol).not.toHaveBeenCalled();
+        });
         test('returns undefined when g2p has no mapping for coord', () => {
             mockGetSession.mockReturnValue({
                 hovered: {
@@ -213,7 +241,8 @@ describe('genomeToMSA', () => {
             const model = {
                 querySeqName: 'QUERY',
                 transcriptToMsaMap: {
-                    g2p: { 1000: 0 }, // No entry for 1005
+                    refName: 'chr1',
+                    g2p: { 1000: 0 }, // No entry for 1004
                 },
                 mafRegion: undefined,
                 connectedView: { initialized: true },