jbrowse-plugin-msaview 3.6.0 → 3.7.0

package/dist/MsaViewPanel/resolveConnectedTranscript.js

@@ -1,22 +1,10 @@
 import { getConf } from '@jbrowse/core/configuration';
 import { getSession } from '@jbrowse/core/util';
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { transaction, untracked } from 'mobx';
 import { getProteinSequenceFromFeature } from '../LaunchMsaView/components/calculateProteinSequence';
 import { fetchSeq } from '../LaunchMsaView/components/fetchSeq';
 import { getTranscriptFeatures } from '../LaunchMsaView/util';
-// The short form of a connected launch. A spec that says
-//
-//   {"type":"MsaView","connectedViewId":"lgv1","connectedTranscript":"NM_000546.6", ...}
-//
-// gets its `connectedFeature` -- the exon model every genome<->column mapping
-// runs through -- looked up here, from the gene tracks the connected genome
-// view has open, and its query row translated from that transcript. Before
-// this the spec had to carry the transcript's CDS list itself, ~1.5kB of
-// coordinates a person cannot type and a tutorial cannot show.
-//
-// jbrowse-plugin-protein3d does the same for its `transcriptId` shorthand,
-// against a `connectedView` spec of its own; here the genome view already
-// exists (the spec pinned its id), so its tracks and regions are read off the
-// live model instead.
 function stripVersion(id) {
     return id.replace(/\.\d+$/, '');
 }
@@ -29,28 +17,51 @@ function transcriptMatches(transcript, id) {
         transcript.id(),
     ].some(c => typeof c === 'string' && (c === id || stripVersion(c) === target));
 }
+function plainRegions(regions) {
+    return regions.map(r => ({
+        assemblyName: r.assemblyName,
+        refName: r.refName,
+        start: Math.floor(r.start),
+        end: Math.ceil(r.end),
+    }));
+}
+/**
+ * The part of the genome on screen, then everything the view can scroll to.
+ * `displayedRegions` is usually whole chromosomes -- navigating to a locus
+ * displays its parent region -- so it is the fallback, not the first ask.
+ */
+export function searchWindows(view) {
+    const visible = plainRegions(view.dynamicBlocks?.contentBlocks ?? []);
+    const displayed = plainRegions(view.displayedRegions);
+    return visible.length > 0 ? [visible, displayed] : [displayed];
+}
+/**
+ * Gene models live on feature tracks. Asking an alignments, variant or
+ * quantitative track for a chromosome's worth of features to look for a
+ * transcript among them is the slowest possible way to find nothing.
+ */
+export function transcriptTracks(tracks) {
+    return tracks.filter(t => t.type === 'FeatureTrack');
+}
 async function findTranscript(self, transcriptId) {
     const view = self.connectedView;
     const session = getSession(self);
     const sessionId = 'msaview-connectedTranscript';
-    const regions = view.displayedRegions.map(r => ({
-        assemblyName: r.assemblyName,
-        refName: r.refName,
-        start: r.start,
-        end: r.end,
-    }));
-    for (const track of view.tracks) {
-        // a named object keeps sessionId, which v4 hosts read from the args
-        const args = {
-            adapterConfig: getConf(track, 'adapter'),
-            sessionId,
-            regions,
-        };
-        const feats = await session.rpcManager.call(sessionId, 'CoreGetFeatures', args);
-        for (const feat of feats) {
-            const hit = getTranscriptFeatures(feat).find(t => transcriptMatches(t, transcriptId));
-            if (hit) {
-                return hit;
+    const tracks = transcriptTracks(view.tracks);
+    for (const regions of searchWindows(view)) {
+        for (const track of tracks) {
+            // a named object keeps sessionId, which v4 hosts read from the args
+            const args = {
+                adapterConfig: getConf(track, 'adapter'),
+                sessionId,
+                regions,
+            };
+            const feats = await session.rpcManager.call(sessionId, 'CoreGetFeatures', args);
+            for (const feat of feats) {
+                const hit = getTranscriptFeatures(feat).find(t => transcriptMatches(t, transcriptId));
+                if (hit) {
+                    return hit;
+                }
             }
         }
     }
@@ -72,37 +83,30 @@ async function translate(self, transcript) {
         assemblyGeneticCodeId,
     });
 }
-/**
- * Resolve `connectedTranscript` into `connectedFeature` once the connected
- * genome view has its assembly, regions and tracks, then hand the translation
- * to whichever launch is waiting for a query. Left in place on failure so the
- * error stays attributable; the autorun's tracked reads are the view's
- * readiness, so nothing refires until that changes.
- */
-export function resolveConnectedTranscriptIfNeeded(self) {
-    const { connectedTranscript, connectedFeature, connectedView } = self;
-    if (!connectedTranscript ||
-        connectedFeature ||
-        !connectedView?.initialized ||
-        connectedView.tracks.length === 0) {
-        return;
-    }
-    const trackCount = connectedView.tracks.length;
-    void (async () => {
-        try {
-            self.setProgress(`Looking up ${connectedTranscript} in the genome view...`);
-            const transcript = await findTranscript(self, connectedTranscript);
-            if (!transcript) {
-                throw new Error(`Transcript "${connectedTranscript}" was not found in the ${trackCount} track(s) open in the connected genome view. Open the gene track that carries it, and make sure the view is on its locus.`);
-            }
-            const proteinSequence = await translate(self, transcript);
-            if (!proteinSequence) {
-                throw new Error(`Transcript "${connectedTranscript}" has no CDS to translate`);
-            }
-            // toJSON, not the Feature: the params are frozen snapshot properties, so
-            // an instance in one is gone the moment the session reloads
-            const transcriptJson = transcript.toJSON();
-            const { blastParams, orthologParams } = self;
+/** the latest lookup per view; an older one finishing late writes nothing */
+const latestLookup = new WeakMap();
+async function lookUp({ self, transcriptId, blastParams, orthologParams, isCurrent, }) {
+    const trackCount = transcriptTracks(self.connectedView.tracks).length;
+    try {
+        self.setProgress(`Looking up ${transcriptId} in the genome view...`);
+        const transcript = await findTranscript(self, transcriptId);
+        if (!transcript) {
+            throw new Error(`Transcript "${transcriptId}" was not found in the ${trackCount} feature track(s) open in the connected genome view. Open the gene track that carries it, and make sure the view is on its locus.`);
+        }
+        const proteinSequence = await translate(self, transcript);
+        if (!proteinSequence) {
+            throw new Error(`Transcript "${transcriptId}" has no CDS to translate`);
+        }
+        if (!isCurrent()) {
+            return;
+        }
+        // toJSON, not the Feature: the params are frozen snapshot properties, so
+        // an instance in one is gone the moment the session reloads
+        const transcriptJson = transcript.toJSON();
+        // one transaction, so the launchers wake once, on a request that already
+        // carries its query
+        transaction(() => {
+            self.setProgress('');
             if (blastParams && !blastParams.proteinSequence) {
                 self.setBlastParams({
                     ...blastParams,
@@ -117,12 +121,43 @@ export function resolveConnectedTranscriptIfNeeded(self) {
                     proteinSequence,
                 });
             }
-            // last, because the launchers wake on it
             self.setConnectedFeature(transcriptJson);
-        }
-        catch (e) {
-            console.error(e);
+        });
+    }
+    catch (e) {
+        console.error(e);
+        if (isCurrent()) {
+            self.setProgress('');
             self.setError(e);
         }
-    })();
+    }
+}
+/**
+ * Resolve `connectedTranscript` into `connectedFeature` once the connected
+ * genome view has its assembly and tracks, then hand the translation to
+ * whichever launch is waiting for a query.
+ *
+ * The autorun re-fires on the view's readiness (a track opened after a miss)
+ * and on the request itself, which is what `retryLaunch` re-states. The lookup
+ * runs untracked, so scrolling the genome view is not a reason to look again.
+ */
+export function resolveConnectedTranscriptIfNeeded(self) {
+    const { connectedTranscript, connectedFeature, connectedView, blastParams, orthologParams, } = self;
+    if (!connectedTranscript ||
+        connectedFeature ||
+        !connectedView?.initialized ||
+        connectedView.tracks.length === 0) {
+        return;
+    }
+    const lookup = (latestLookup.get(self) ?? 0) + 1;
+    latestLookup.set(self, lookup);
+    untracked(() => {
+        void lookUp({
+            self,
+            transcriptId: connectedTranscript,
+            blastParams,
+            orthologParams,
+            isCurrent: () => isAlive(self) && latestLookup.get(self) === lookup,
+        });
+    });
 }

package/dist/MsaViewPanel/resolveConnectedTranscript.test.d.ts

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

package/dist/MsaViewPanel/resolveConnectedTranscript.test.js

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import stateModelFactory from './model';
+const rpcCall = vi.fn();
+const lgv = {
+    id: 'lgv1',
+    initialized: true,
+    assemblyNames: ['hg38'],
+    tracks: [],
+    displayedRegions: [
+        { assemblyName: 'hg38', refName: 'chr17', start: 0, end: 83_257_441 },
+    ],
+    dynamicBlocks: {
+        contentBlocks: [],
+    },
+};
+vi.mock('@jbrowse/core/util', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getSession: () => ({
+        views: [lgv],
+        hovered: undefined,
+        rpcManager: { call: rpcCall },
+    }),
+}));
+vi.mock('@jbrowse/core/configuration', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getConf: (track) => track.adapter,
+}));
+vi.mock('../LaunchMsaView/components/fetchSeq', () => ({
+    fetchSeq: vi.fn(async () => ({ seq: 'ATGAAAGTG' })),
+}));
+vi.mock('../LaunchMsaView/components/calculateProteinSequence', () => ({
+    getProteinSequenceFromFeature: vi.fn(() => 'MKV'),
+}));
+vi.mock('./doLaunchBlast', () => ({
+    doLaunchBlast: vi.fn(() => new Promise(() => { })),
+}));
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(async () => { }),
+    deleteMsaData: vi.fn(async () => { }),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(),
+}));
+function transcript(id) {
+    const json = { uniqueId: id, id, refName: 'chr17', start: 0, end: 9 };
+    return {
+        id: () => id,
+        get: (key) => (key === 'id' || key === 'name' ? id : undefined),
+        toJSON: () => json,
+    };
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+function connectedView() {
+    return stateModelFactory().create({
+        type: 'MsaView',
+        id: 'msa1',
+        connectedViewId: 'lgv1',
+        connectedTranscript: 'NM_000546.6',
+        blastParams: {
+            searchProgram: 'blastp',
+            blastDatabase: 'uniprotkb_swissprot',
+            msaAlgorithm: 'clustalo',
+        },
+    });
+}
+beforeEach(() => {
+    rpcCall.mockReset();
+    lgv.tracks = [{ type: 'FeatureTrack', adapter: 'genes' }];
+    lgv.dynamicBlocks.contentBlocks = [];
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+});
+describe('a lookup that misses', () => {
+    test('reports the miss without leaving its progress up', async () => {
+        rpcCall.mockResolvedValue([]);
+        const model = connectedView();
+        await settle();
+        expect(model.error).toBeInstanceOf(Error);
+        expect(model.progress).toBe('');
+    });
+    test('Retry looks again', async () => {
+        rpcCall.mockResolvedValue([]);
+        const model = connectedView();
+        await settle();
+        const calls = rpcCall.mock.calls.length;
+        rpcCall.mockResolvedValue([transcript('NM_000546.6')]);
+        model.retryLaunch();
+        await settle();
+        expect(rpcCall.mock.calls.length).toBeGreaterThan(calls);
+        expect(model.connectedFeature).toMatchObject({ id: 'NM_000546.6' });
+        expect(model.blastParams?.proteinSequence).toBe('MKV');
+    });
+});
+describe('where a lookup searches', () => {
+    test('feature tracks only, on screen before the whole chromosome', async () => {
+        rpcCall.mockResolvedValue([]);
+        lgv.tracks = [
+            { type: 'AlignmentsTrack', adapter: 'bam' },
+            { type: 'FeatureTrack', adapter: 'genes' },
+        ];
+        lgv.dynamicBlocks.contentBlocks = [
+            {
+                assemblyName: 'hg38',
+                refName: 'chr17',
+                start: 7_661_778.6,
+                end: 7_687_538.2,
+            },
+        ];
+        connectedView();
+        await settle();
+        const asked = rpcCall.mock.calls.map(([, , args]) => [
+            args.adapterConfig,
+            args.regions,
+        ]);
+        expect(asked).toEqual([
+            [
+                'genes',
+                [
+                    {
+                        assemblyName: 'hg38',
+                        refName: 'chr17',
+                        start: 7_661_778,
+                        end: 7_687_539,
+                    },
+                ],
+            ],
+            ['genes', lgv.displayedRegions],
+        ]);
+    });
+});
+describe('two lookups in flight', () => {
+    test('only the later one writes', async () => {
+        const pending = [];
+        rpcCall.mockImplementation(() => new Promise(res => {
+            pending.push(res);
+        }));
+        const model = connectedView();
+        await settle();
+        model.retryLaunch();
+        await settle();
+        expect(pending).toHaveLength(2);
+        pending[1]([transcript('NM_000546.6')]);
+        await settle();
+        const written = model.connectedFeature;
+        pending[0]([transcript('NM_000546.5')]);
+        await settle();
+        expect(written).toMatchObject({ id: 'NM_000546.6' });
+        expect(model.connectedFeature).toBe(written);
+    });
+});

package/dist/MsaViewPanel/runLaunch.d.ts

@@ -26,11 +26,15 @@ interface LaunchedData {
  * Run one launch attempt, owning the AbortController that ties it to the view.
  *
  * The controller lives on the model because two things end a launch and neither
- * is here: the Cancel button, and the disposer `afterCreate` registers. Before
- * it existed, closing a view mid-BLAST left the poller checking EBI for the
- * job's lifetime and then writing to a node that was gone.
+ * is here: the Cancel button, and the disposer `afterCreate` registers. A launch
+ * already holding it is aborted first, so a re-fired autorun replaces the
+ * attempt rather than orphaning one that nothing can cancel.
+ *
+ * Runs untracked: it is called from the launch autoruns, and whatever the
+ * launch body reads before its first await would otherwise become a reason to
+ * launch again.
  */
-export declare function runLaunch({ self, message, launch, onLaunched, }: {
+export declare function runLaunch(args: {
     self: JBrowsePluginMsaViewModel;
     message: string;
     launch: (scope: LaunchScope) => Promise<LaunchedData>;

package/dist/MsaViewPanel/runLaunch.js

@@ -1,4 +1,5 @@
 import { getSession } from '@jbrowse/core/util';
+import { untracked } from 'mobx';
 import { isAbortError } from '../utils/fetch';
 /**
  * The in-browser aligner and a search hand back rows and no tree;
@@ -33,11 +34,21 @@ function buildTree(self) {
  * Run one launch attempt, owning the AbortController that ties it to the view.
  *
  * The controller lives on the model because two things end a launch and neither
- * is here: the Cancel button, and the disposer `afterCreate` registers. Before
- * it existed, closing a view mid-BLAST left the poller checking EBI for the
- * job's lifetime and then writing to a node that was gone.
+ * is here: the Cancel button, and the disposer `afterCreate` registers. A launch
+ * already holding it is aborted first, so a re-fired autorun replaces the
+ * attempt rather than orphaning one that nothing can cancel.
+ *
+ * Runs untracked: it is called from the launch autoruns, and whatever the
+ * launch body reads before its first await would otherwise become a reason to
+ * launch again.
  */
-export function runLaunch({ self, message, launch, onLaunched, }) {
+export function runLaunch(args) {
+    untracked(() => {
+        startLaunch(args);
+    });
+}
+function startLaunch({ self, message, launch, onLaunched, }) {
+    self.launchController?.abort();
     const controller = new AbortController();
     const { signal } = controller;
     self.setLaunchController(controller);

package/dist/MsaViewPanel/runLaunch.test.js

@@ -112,6 +112,22 @@ describe('a launch that is abandoned', () => {
         expect(writes.some(w => w.startsWith('setError:Aborted'))).toBe(false);
     });
 });
+describe('a launch started while another holds the controller', () => {
+    test('aborts the first, so nothing is left polling that Cancel cannot reach', async () => {
+        const { model } = makeModel();
+        const signals = [];
+        const launch = (scope) => {
+            signals.push(scope.signal);
+            return new Promise(() => { });
+        };
+        runLaunch({ self: model, message: 'a', onLaunched: () => { }, launch });
+        runLaunch({ self: model, message: 'b', onLaunched: () => { }, launch });
+        await settle();
+        expect(signals.map(s => s.aborted)).toEqual([true, false]);
+        model.launchController.abort();
+        expect(signals[1].aborted).toBe(true);
+    });
+});
 describe('a launch that fails', () => {
     test('records the error and stops the spinner', async () => {
         vi.spyOn(console, 'error').mockImplementation(() => { });

package/dist/MsaViewPanel/storedData.test.js

@@ -49,6 +49,9 @@ function makeModel(over = {}) {
         setTreeMetadata(arg) {
             model.data.treeMetadata = arg;
         },
+        setGFF(arg) {
+            model.data.gff = arg;
+        },
         ...over,
     };
     return model;
@@ -82,6 +85,14 @@ describe('restoring a view from IndexedDB', () => {
         storeDataToIndexedDB(model);
         expect(mockStore).not.toHaveBeenCalled();
     });
+    // react-msaview drops a GFF over 50kB from the snapshot too
+    test('a stored GFF comes back with the alignment', async () => {
+        mockRetrieve.mockResolvedValue({ msa: MSA, gff: 'a\t.\tdomain\t1\t2' });
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.data.gff).toBe('a\t.\tdomain\t1\t2');
+    });
     // the row expires or the user clears site data, and the view used to reopen as
     // a blank import form with no hint that anything had been lost
     test('a row that is gone says so, in words that name the policy', async () => {
@@ -147,6 +158,18 @@ describe('keeping IndexedDB up to date', () => {
         });
         expect(model.dataStoreId).toBe('msa-1');
     });
+    test('a GFF loaded after the first write updates the row', async () => {
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            lastStoredData: { msa: MSA },
+        });
+        model.data.gff = 'a\t.\tdomain\t1\t2';
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith('msa-1', expect.objectContaining({ gff: 'a\t.\tdomain\t1\t2' }));
+    });
     // a browser that refuses IndexedDB (private mode) answers every write the same
     // way, and the autorun reruns on its own isStoringData flag -- so a write that
     // is not recorded as attempted is a write that retries forever

package/dist/MsaViewPanel/syncGenomeHoverToMsaColumn.test.js

@@ -15,17 +15,18 @@ const mafRegion = {
     assemblyName: 'hg38',
 };
 // A model wired through the real genomeToMSA path: a connected genome view
-// over a maf region, with seqPosToVisibleCol as identity so the asserted
+// over a maf region, with the column converters as identity so the asserted
 // column equals the ungapped offset into the region.
 function makeModel() {
     const calls = [];
     const model = {
         querySeqName: 'hg38.chr1',
-        rows: [['hg38.chr1', 'ACGTACGTAC']],
+        rowMap: new Map([['hg38.chr1', 'ACGTACGTAC']]),
         transcriptToMsaMap: undefined,
         mafRegion,
         connectedView: { initialized: true, assemblyNames: ['hg38'] },
         seqPosToVisibleCol: (_name, pos) => pos,
+        visibleColToSeqPos: (_name, col) => col,
         setMousePos: (col) => {
             calls.push(col);
         },

package/dist/MsaViewPanel/util.d.ts

@@ -1,19 +1,14 @@
 /**
- * Whether `querySeqName` names a row this alignment actually has.
+ * Whether `querySeqName` names a row this alignment actually has. The name
+ * defaults to `QUERY`, which an uploaded alignment has no reason to carry, so
+ * the genome and structure hovers ask this before mapping anything.
  *
- * react-msaview's `seqPosToGlobalCol` answers 0 for a name it does not know, so
- * without this every genome position maps to the first column and hovering the
- * genome — or a connected structure — lights column 0 of an unrelated row. The
- * name is wrong more often than it looks: it defaults to `QUERY`, which an
- * uploaded alignment has no reason to carry, and the manual panel leaves it
- * empty when it cannot match the protein to a row.
- *
- * The other direction has no such hole: msaCoordToGenomeRegions needs the query
- * row's sequence to map a column at all, so a missing row is already nothing
- * there.
+ * `rowMap`, not `rows`: `rows` is what is on screen, and a query row folded
+ * into a collapsed clade is still in the alignment, still has its columns, and
+ * still maps.
  */
 export declare function hasQueryRow(model: {
-    rows: string[][];
+    rowMap: ReadonlyMap<string, string>;
     querySeqName: string;
 }): boolean;
 /**
@@ -35,23 +30,28 @@ interface LiveFeature {
 export declare function transcriptFields(transcript?: TranscriptRef): Record<string, unknown>;
 /** what a transcript is called, preferring its name over its id */
 export declare function transcriptName(transcript?: TranscriptRef): string | undefined;
-export interface QueryRowModel {
+interface QueryRowColumns {
     querySeqName: string;
-    querySeqOffset: number;
     seqPosToVisibleCol: (rowName: string, seqPos: number) => number | undefined;
     visibleColToSeqPos: (rowName: string, visibleCol: number) => number | undefined;
 }
+export interface QueryRowModel extends QueryRowColumns {
+    querySeqOffset: number;
+}
 /**
- * The visible column showing residue `proteinPos` (0-based) of the transcript,
- * or undefined when the query row does not carry that residue or react-msaview
- * is hiding its column.
+ * The visible column showing residue `seqPos` (0-based) of the query row, or
+ * undefined when the row does not carry that residue or react-msaview is
+ * hiding its column.
  *
- * Two things separate the transcript from the row. `querySeqOffset` is the
- * trimming — a pasted BLAST alignment carries the aligned region, not the whole
- * protein. And the row can simply stop short: react-msaview answers one column
- * past the end for a position it does not have, which would light the last
- * column for every residue beyond the row, so the round trip back through
- * visibleColToSeqPos is what rejects those.
+ * react-msaview answers one column past the end for a position the row does not
+ * have, which would light the last column for every residue beyond the row, so
+ * the round trip back through visibleColToSeqPos is what rejects those.
+ */
+export declare function querySeqPosToVisibleCol(model: QueryRowColumns, seqPos: number): number | undefined;
+/**
+ * The visible column showing residue `proteinPos` (0-based) of the transcript.
+ * `querySeqOffset` is what separates the two: a pasted BLAST alignment carries
+ * the aligned region, not the whole protein.
  */
 export declare function transcriptPosToVisibleCol(model: QueryRowModel, proteinPos: number): number | undefined;
 export declare function hasHoverPosition(hovered: unknown): hovered is {

package/dist/MsaViewPanel/util.js

@@ -1,19 +1,14 @@
 /**
- * Whether `querySeqName` names a row this alignment actually has.
+ * Whether `querySeqName` names a row this alignment actually has. The name
+ * defaults to `QUERY`, which an uploaded alignment has no reason to carry, so
+ * the genome and structure hovers ask this before mapping anything.
  *
- * react-msaview's `seqPosToGlobalCol` answers 0 for a name it does not know, so
- * without this every genome position maps to the first column and hovering the
- * genome — or a connected structure — lights column 0 of an unrelated row. The
- * name is wrong more often than it looks: it defaults to `QUERY`, which an
- * uploaded alignment has no reason to carry, and the manual panel leaves it
- * empty when it cannot match the protein to a row.
- *
- * The other direction has no such hole: msaCoordToGenomeRegions needs the query
- * row's sequence to map a column at all, so a missing row is already nothing
- * there.
+ * `rowMap`, not `rows`: `rows` is what is on screen, and a query row folded
+ * into a collapsed clade is still in the alignment, still has its columns, and
+ * still maps.
  */
 export function hasQueryRow(model) {
-    return model.rows.some(r => r[0] === model.querySeqName);
+    return model.rowMap.has(model.querySeqName);
 }
 /**
  * Read the transcript's fields whichever shape it arrived in: a caller inside
@@ -36,20 +31,16 @@ export function transcriptName(transcript) {
     return str(fields.name) ?? str(fields.id);
 }
 /**
- * The visible column showing residue `proteinPos` (0-based) of the transcript,
- * or undefined when the query row does not carry that residue or react-msaview
- * is hiding its column.
+ * The visible column showing residue `seqPos` (0-based) of the query row, or
+ * undefined when the row does not carry that residue or react-msaview is
+ * hiding its column.
  *
- * Two things separate the transcript from the row. `querySeqOffset` is the
- * trimming — a pasted BLAST alignment carries the aligned region, not the whole
- * protein. And the row can simply stop short: react-msaview answers one column
- * past the end for a position it does not have, which would light the last
- * column for every residue beyond the row, so the round trip back through
- * visibleColToSeqPos is what rejects those.
+ * react-msaview answers one column past the end for a position the row does not
+ * have, which would light the last column for every residue beyond the row, so
+ * the round trip back through visibleColToSeqPos is what rejects those.
  */
-export function transcriptPosToVisibleCol(model, proteinPos) {
-    const { querySeqName, querySeqOffset } = model;
-    const seqPos = proteinPos - querySeqOffset;
+export function querySeqPosToVisibleCol(model, seqPos) {
+    const { querySeqName } = model;
     if (seqPos < 0) {
         return undefined;
     }
@@ -59,6 +50,14 @@ export function transcriptPosToVisibleCol(model, proteinPos) {
         ? col
         : undefined;
 }
+/**
+ * The visible column showing residue `proteinPos` (0-based) of the transcript.
+ * `querySeqOffset` is what separates the two: a pasted BLAST alignment carries
+ * the aligned region, not the whole protein.
+ */
+export function transcriptPosToVisibleCol(model, proteinPos) {
+    return querySeqPosToVisibleCol(model, proteinPos - model.querySeqOffset);
+}
 export function hasHoverPosition(hovered) {
     return (!!hovered &&
         typeof hovered === 'object' &&