jbrowse-plugin-msaview 3.4.0 → 3.5.0

package/dist/MsaViewPanel/resolveConnectedTranscript.js

@@ -0,0 +1,122 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { getSession } from '@jbrowse/core/util';
+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+$/, '');
+}
+function transcriptMatches(transcript, id) {
+    const target = stripVersion(id);
+    return [
+        transcript.get('name'),
+        transcript.get('id'),
+        transcript.get('transcript_id'),
+        transcript.id(),
+    ].some(c => typeof c === 'string' && (c === id || stripVersion(c) === target));
+}
+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) {
+        const feats = (await session.rpcManager.call(sessionId, 'CoreGetFeatures', {
+            adapterConfig: getConf(track, 'adapter'),
+            sessionId,
+            regions,
+        }));
+        for (const feat of feats) {
+            const hit = getTranscriptFeatures(feat).find(t => transcriptMatches(t, transcriptId));
+            if (hit) {
+                return hit;
+            }
+        }
+    }
+    return undefined;
+}
+async function translate(self, transcript) {
+    const { start, end, refName } = transcript.toJSON();
+    const assemblyName = self.connectedView.assemblyNames[0];
+    const seq = await fetchSeq({
+        start,
+        end,
+        refName,
+        assemblyName,
+        session: getSession(self),
+    });
+    return getProteinSequenceFromFeature({ seq, feature: transcript });
+}
+/**
+ * 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;
+            if (blastParams && !blastParams.proteinSequence) {
+                self.setBlastParams({
+                    ...blastParams,
+                    selectedTranscript: transcriptJson,
+                    proteinSequence,
+                });
+            }
+            if (orthologParams && !orthologParams.proteinSequence) {
+                self.setOrthologParams({
+                    ...orthologParams,
+                    selectedTranscript: transcriptJson,
+                    proteinSequence,
+                });
+            }
+            // last, because the launchers wake on it
+            self.setConnectedFeature(transcriptJson);
+        }
+        catch (e) {
+            console.error(e);
+            self.setError(e);
+        }
+    })();
+}

package/dist/MsaViewPanel/runLaunch.d.ts

@@ -0,0 +1,39 @@
+import type { JBrowsePluginMsaViewModel } from './model';
+/**
+ * What a launch is allowed to do to the model and to the network while it runs.
+ *
+ * Every write a launch makes goes through `act`, so "nothing touches the model
+ * once the launch has been abandoned" is one rule in one place. Spreading that
+ * guard across the call sites only takes one omission to undo: an abandoned
+ * launch keeps running until its next network hop rejects, and an action on a
+ * destroyed mobx-state-tree node throws where nothing is catching.
+ */
+export interface LaunchScope {
+    /** aborts when the user cancels, and when the view is destroyed */
+    signal: AbortSignal;
+    act: (fn: () => void) => void;
+    onProgress: (arg: string) => void;
+    /** the EBI job id, published before the first poll so the view can link out */
+    onRid: (arg: string) => void;
+}
+interface LaunchedData {
+    msa: string;
+    /** empty when the aligner built no tree, and one is then built in the browser */
+    tree: string;
+    treeMetadata: string;
+}
+/**
+ * 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.
+ */
+export declare function runLaunch({ self, message, launch, onLaunched, }: {
+    self: JBrowsePluginMsaViewModel;
+    message: string;
+    launch: (scope: LaunchScope) => Promise<LaunchedData>;
+    onLaunched: () => void;
+}): void;
+export {};

package/dist/MsaViewPanel/runLaunch.js

@@ -0,0 +1,100 @@
+import { getSession } from '@jbrowse/core/util';
+import { isAbortError } from '../utils/fetch';
+/**
+ * The in-browser aligner and a search hand back rows and no tree;
+ * react-msaview's neighbour joining over the finished alignment is what EBI's
+ * simple_phylogeny would have computed, without the job.
+ *
+ * It runs after the alignment is applied, and its refusals are reported rather
+ * than thrown: the library caps neighbour joining by row count and throws above
+ * it, and inside the success path that throw discarded an alignment that had
+ * just cost fifteen minutes of EBI queue behind "Running EBI BLAST failed".
+ * A search asking for 1000 hits clears that cap on its own.
+ */
+function buildTree(self) {
+    if (self.rows.length < 2) {
+        return;
+    }
+    try {
+        self.calculateNeighborJoiningTreeFromMSA();
+    }
+    catch (e) {
+        console.error(e);
+        // a notice, not the view's error: the alignment is fine and on screen
+        try {
+            getSession(self).notify(`The alignment loaded, but no tree was built. ${e instanceof Error ? e.message : String(e)}`, 'warning');
+        }
+        catch (e2) {
+            console.error(e2);
+        }
+    }
+}
+/**
+ * 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.
+ */
+export function runLaunch({ self, message, launch, onLaunched, }) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    self.setLaunchController(controller);
+    const act = (fn) => {
+        if (!signal.aborted) {
+            fn();
+        }
+    };
+    const scope = {
+        signal,
+        act,
+        onProgress: arg => {
+            act(() => {
+                self.setProgress(arg);
+            });
+        },
+        onRid: arg => {
+            act(() => {
+                self.setRid(arg);
+            });
+        },
+    };
+    void (async () => {
+        try {
+            act(() => {
+                self.setProgress(message);
+                self.setError(undefined);
+            });
+            const data = await launch(scope);
+            act(() => {
+                self.setData(data);
+                onLaunched();
+            });
+            if (!data.tree) {
+                act(() => {
+                    buildTree(self);
+                });
+            }
+        }
+        catch (e) {
+            // a cancel is not a failure: drawing the error panel for one would tell
+            // the user their launch broke when they are the one who stopped it
+            if (!isAbortError(e)) {
+                act(() => {
+                    self.setError(e);
+                });
+                console.error(e);
+            }
+        }
+        finally {
+            act(() => {
+                self.setProgress('');
+                // only if a later launch has not already claimed the slot
+                if (self.launchController === controller) {
+                    self.setLaunchController(undefined);
+                }
+            });
+        }
+    })();
+}

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

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

package/dist/MsaViewPanel/runLaunch.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, test, vi } from 'vitest';
+import { runLaunch } from './runLaunch';
+/**
+ * A model that records every write, so "no model actions after abort" is
+ * assertable rather than inferred. The real thing throws on a destroyed node;
+ * here a write that should not have happened simply shows up in the log.
+ */
+function makeModel() {
+    const writes = [];
+    const model = {
+        launchController: undefined,
+        setLaunchController(arg) {
+            model.launchController = arg;
+            writes.push(`setLaunchController:${arg ? 'set' : 'cleared'}`);
+        },
+        setProgress: (arg) => writes.push(`setProgress:${arg}`),
+        setError: (e) => writes.push(`setError:${e instanceof Error ? e.message : String(e)}`),
+        setRid: (arg) => writes.push(`setRid:${arg}`),
+        setData: () => writes.push('setData'),
+        rows: [],
+        calculateNeighborJoiningTreeFromMSA: () => writes.push('neighborJoining'),
+    };
+    return { model, writes };
+}
+const DATA = { msa: '>a\nMK', tree: '(a);', treeMetadata: '{}' };
+/** run the microtask queue out so the launch's async body has finished */
+const settle = () => new Promise(res => setTimeout(res, 0));
+describe('a launch that finishes', () => {
+    test('applies its data, clears its params and releases the controller', async () => {
+        const { model, writes } = makeModel();
+        const onLaunched = vi.fn();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched,
+            launch: async (scope) => {
+                scope.onRid('ncbiblast-1');
+                scope.onProgress('Re-checking BLAST status in... 7');
+                return DATA;
+            },
+        });
+        await settle();
+        expect(writes).toEqual([
+            'setLaunchController:set',
+            'setProgress:Submitting query',
+            'setError:undefined',
+            'setRid:ncbiblast-1',
+            'setProgress:Re-checking BLAST status in... 7',
+            'setData',
+            'setProgress:',
+            'setLaunchController:cleared',
+        ]);
+        expect(onLaunched).toHaveBeenCalled();
+    });
+});
+// The failure this file exists for: closing a view mid-BLAST left the poller
+// running for the job's lifetime and then writing to a destroyed
+// mobx-state-tree node, whose throw surfaced as an unhandled rejection.
+describe('a launch that is abandoned', () => {
+    async function abandonMidFlight(reject) {
+        const { model, writes } = makeModel();
+        let released;
+        const held = new Promise(res => {
+            released = res;
+        });
+        let captured;
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => {
+                throw new Error('a cancelled launch must not report success');
+            },
+            launch: async (scope) => {
+                captured = scope;
+                await held;
+                // what the network hop does once its signal is aborted: either it
+                // rejects with an AbortError, or it had already resolved and returns
+                if (reject) {
+                    throw new DOMException('Aborted', 'AbortError');
+                }
+                return DATA;
+            },
+        });
+        await settle();
+        const before = writes.length;
+        model.launchController.abort();
+        // everything the launch would still try to do after the abort
+        captured.onProgress('Re-checking BLAST status in... 3');
+        captured.onRid('ncbiblast-2');
+        captured.act(() => {
+            throw new Error('act must not run its callback after an abort');
+        });
+        released();
+        await settle();
+        return writes.slice(before);
+    }
+    test('nothing is written to the model once the abort lands', async () => {
+        expect(await abandonMidFlight(true)).toEqual([]);
+    });
+    test('a launch that resolved anyway still applies nothing', async () => {
+        expect(await abandonMidFlight(false)).toEqual([]);
+    });
+    test('an abort renders no error, so a cancel does not read as a failure', async () => {
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => { },
+            launch: () => Promise.reject(new DOMException('Aborted', 'AbortError')),
+        });
+        await settle();
+        expect(writes.some(w => w.startsWith('setError:Aborted'))).toBe(false);
+    });
+});
+describe('a launch that fails', () => {
+    test('records the error and stops the spinner', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Resolving orthologs',
+            onLaunched: () => {
+                throw new Error('a failed launch must not report success');
+            },
+            launch: () => Promise.reject(new Error('Only 1 ortholog(s) found')),
+        });
+        await settle();
+        expect(writes).toContain('setError:Only 1 ortholog(s) found');
+        expect(writes.at(-2)).toBe('setProgress:');
+    });
+});
+// react-msaview caps neighbor joining by row count and throws above it, and a
+// search can ask for 1000 hits. Thrown from inside the success path, that
+// discarded a finished alignment behind "Running EBI BLAST failed".
+describe('a launch whose alignment is too big to build a tree from', () => {
+    test('keeps the alignment and reports the refusal', async () => {
+        const { model, writes } = makeModel();
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        model.rows = [
+            ['a', 'MK'],
+            ['b', 'MK'],
+        ];
+        model.calculateNeighborJoiningTreeFromMSA = () => {
+            throw new Error('Neighbor joining here is capped at 500 sequences');
+        };
+        const onLaunched = vi.fn();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched,
+            launch: async () => ({ ...DATA, tree: '' }),
+        });
+        await settle();
+        expect(writes).toContain('setData');
+        expect(onLaunched).toHaveBeenCalled();
+        expect(writes.filter(w => w.startsWith('setError:'))).toEqual([
+            'setError:undefined',
+        ]);
+    });
+    test('builds the tree when the alignment came back without one', async () => {
+        const { model, writes } = makeModel();
+        model.rows = [
+            ['a', 'MK'],
+            ['b', 'MK'],
+        ];
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: vi.fn(),
+            launch: async () => ({ ...DATA, tree: '' }),
+        });
+        await settle();
+        expect(writes).toContain('neighborJoining');
+    });
+});

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

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

package/dist/MsaViewPanel/storedData.test.js

@@ -0,0 +1,160 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { loadStoredData, storeDataToIndexedDB } from './afterCreateAutoruns';
+import { generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
+// IndexedDB itself is msaDataStore.test.ts's subject; what is under test here is
+// which writes these two autoruns decide to make.
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(),
+}));
+const mockRetrieve = vi.mocked(retrieveMsaData);
+const mockStore = vi.mocked(storeMsaData);
+const mockGenerateId = vi.mocked(generateDataStoreId);
+const MSA = '>a\nMK';
+const NEW_ID = 'msa-generated';
+function makeModel(over = {}) {
+    const model = {
+        dataStoreId: undefined,
+        rows: [],
+        data: {},
+        msaFilehandle: undefined,
+        treeFilehandle: undefined,
+        isStoringData: false,
+        lastStoredData: undefined,
+        loadingStoredData: false,
+        error: undefined,
+        setDataStoreId(arg) {
+            model.dataStoreId = arg;
+        },
+        setIsStoringData(arg) {
+            model.isStoringData = arg;
+        },
+        setLastStoredData(arg) {
+            model.lastStoredData = arg;
+        },
+        setLoadingStoredData(arg) {
+            model.loadingStoredData = arg;
+        },
+        setError(arg) {
+            model.error = arg;
+        },
+        setMSA(arg) {
+            model.data.msa = arg;
+        },
+        setTree(arg) {
+            model.data.tree = arg;
+        },
+        setTreeMetadata(arg) {
+            model.data.treeMetadata = arg;
+        },
+        ...over,
+    };
+    return model;
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGenerateId.mockReturnValue(NEW_ID);
+    mockStore.mockResolvedValue(true);
+});
+describe('restoring a view from IndexedDB', () => {
+    test('a row that is still there is applied and recorded as stored', async () => {
+        mockRetrieve.mockResolvedValue({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.data.msa).toBe(MSA);
+        expect(model.error).toBeUndefined();
+        // recorded, so the store autorun does not write the restored data straight
+        // back out again
+        expect(model.lastStoredData).toEqual({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        model.rows = [['a', 'MK']];
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    // 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 () => {
+        mockRetrieve.mockResolvedValue(undefined);
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.error).toBeInstanceOf(Error);
+        expect(model.error.message).toMatch(/7 days/);
+        // the id names nothing now, so it goes -- otherwise react-msaview's "Return
+        // to import form" lands straight back on this error
+        expect(model.dataStoreId).toBeUndefined();
+    });
+});
+describe('keeping IndexedDB up to date', () => {
+    test('the first alignment is written under a fresh id', async () => {
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith(NEW_ID, { msa: MSA });
+        expect(model.dataStoreId).toBe(NEW_ID);
+        expect(model.isStoringData).toBe(false);
+    });
+    // react-msaview's "calculate neighbor-joining tree" replaces data.tree long
+    // after the first write; the row used to keep the alignment's original tree
+    // forever, so a reopened session restored a picture the user had replaced
+    test('an edit after the first write updates the existing row', async () => {
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            rows: [['a', 'MK']],
+            data: { msa: MSA, tree: '(a);' },
+            lastStoredData: { msa: MSA, tree: '(a);' },
+        });
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+        model.data.tree = '(a:0.1);';
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith('msa-1', {
+            msa: MSA,
+            tree: '(a:0.1);',
+            treeMetadata: undefined,
+        });
+        expect(model.dataStoreId).toBe('msa-1');
+    });
+    // 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
+    test('a write that fails is not retried on the same data', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockStore.mockResolvedValue(false);
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(model.dataStoreId).toBeUndefined();
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledTimes(1);
+    });
+    test('a view reading from a filehandle stores nothing, since the file is the source', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            msaFilehandle: { uri: 'msa.fa', locationType: 'UriLocation' },
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    test('a write already in flight is not duplicated', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            isStoringData: true,
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+});

package/dist/MsaViewPanel/structureConnection.d.ts

@@ -27,7 +27,3 @@ export declare function isProteinView(view: unknown): view is ProteinView;
 export declare function getProteinViews(views: {
     type: string;
 }[]): ProteinView[];
-/**
- * Helper to convert gapped MSA column to ungapped position for a specific row
- */
-export declare function gappedToUngappedPosition(sequence: string, gappedPosition: number): number | undefined;

package/dist/MsaViewPanel/structureConnection.js

@@ -8,22 +8,3 @@ export function isProteinView(view) {
 export function getProteinViews(views) {
     return views.filter(isProteinView);
 }
-/**
- * Helper to convert gapped MSA column to ungapped position for a specific row
- */
-export function gappedToUngappedPosition(sequence, gappedPosition) {
-    if (gappedPosition < 0 || gappedPosition >= sequence.length) {
-        return undefined;
-    }
-    let ungapped = 0;
-    for (let i = 0; i < gappedPosition; i++) {
-        if (sequence[i] !== '-') {
-            ungapped++;
-        }
-    }
-    // If the position itself is a gap, return undefined
-    if (sequence[gappedPosition] === '-') {
-        return undefined;
-    }
-    return ungapped;
-}

package/dist/MsaViewPanel/util.d.ts

@@ -16,6 +16,44 @@ export declare function hasQueryRow(model: {
     rows: string[][];
     querySeqName: string;
 }): boolean;
+/**
+ * The transcript a launch was started from, as it is stored: plain JSON.
+ *
+ * blastParams and orthologParams are frozen snapshot properties, so a Feature
+ * instance put in one lives only as long as the tab. A reloaded session hands
+ * back the JSON the instance serialized to, and `.get()` on that threw --
+ * minutes after the EBI job the reload resubmitted had finally come back.
+ */
+export type TranscriptRef = Record<string, unknown> | LiveFeature;
+interface LiveFeature {
+    toJSON: () => Record<string, unknown>;
+}
+/**
+ * Read the transcript's fields whichever shape it arrived in: a caller inside
+ * the session may still hand over a live Feature.
+ */
+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 {
+    querySeqName: string;
+    querySeqOffset: number;
+    seqPosToVisibleCol: (rowName: string, seqPos: number) => number | undefined;
+    visibleColToSeqPos: (rowName: string, visibleCol: number) => number | undefined;
+}
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare function transcriptPosToVisibleCol(model: QueryRowModel, proteinPos: number): number | undefined;
 export declare function hasHoverPosition(hovered: unknown): hovered is {
     hoverPosition: {
         coord: number;
@@ -29,3 +67,4 @@ export declare function hasHoverPosition(hovered: unknown): hovered is {
  * - https://alphafold.ebi.ac.uk/files/msa/AF-P12345-F1-msa_v6.a3m -> P12345
  */
 export declare function getUniprotIdFromAlphaFoldUrl(url: string): string | undefined;
+export {};