jbrowse-plugin-msaview 3.6.0 → 3.7.0

package/dist/utils/idb.test.js

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { bestEffort, createDbOpener } from './idb';
+const { opens } = vi.hoisted(() => ({ opens: [] }));
+vi.mock('idb', () => ({
+    openDB: (_name, _version, callbacks) => new Promise((resolve, reject) => {
+        opens.push({ callbacks, resolve, reject });
+    }),
+}));
+function fakeDb() {
+    return { close: vi.fn() };
+}
+beforeEach(() => {
+    opens.length = 0;
+});
+describe('createDbOpener', () => {
+    test('shares one connection between callers', async () => {
+        const getDB = createDbOpener('db', 1, () => { });
+        const first = getDB();
+        const second = getDB();
+        const db = fakeDb();
+        opens[0].resolve(db);
+        expect(await first).toBe(db);
+        expect(await second).toBe(db);
+        expect(opens.length).toBe(1);
+    });
+    test('a failed open is retried by the next caller', async () => {
+        const getDB = createDbOpener('db', 1, () => { });
+        const first = getDB();
+        opens[0].reject(new Error('private mode'));
+        await expect(first).rejects.toThrow('private mode');
+        void getDB();
+        expect(opens.length).toBe(2);
+    });
+    test('an open blocked by another tab rejects instead of waiting on it', async () => {
+        const getDB = createDbOpener('db', 2, () => { });
+        const first = getDB();
+        opens[0].callbacks.blocked(1, 2, {});
+        await expect(first).rejects.toThrow(/held open at version 1/);
+        // the upgrade goes through once the other tab lets go, and the connection
+        // nobody is waiting for any more is closed rather than leaked
+        const late = fakeDb();
+        opens[0].resolve(late);
+        await Promise.resolve();
+        expect(late.close).toHaveBeenCalled();
+    });
+    test('a connection blocking another tab closes and is reopened on next use', async () => {
+        const getDB = createDbOpener('db', 1, () => { });
+        const pending = getDB();
+        const db = fakeDb();
+        opens[0].resolve(db);
+        await pending;
+        const target = { close: vi.fn() };
+        opens[0].callbacks.blocking(1, 2, {
+            target,
+        });
+        expect(target.close).toHaveBeenCalled();
+        void getDB();
+        expect(opens.length).toBe(2);
+    });
+    test('a terminated connection is reopened on next use', async () => {
+        const getDB = createDbOpener('db', 1, () => { });
+        const pending = getDB();
+        opens[0].resolve(fakeDb());
+        await pending;
+        opens[0].callbacks.terminated();
+        void getDB();
+        expect(opens.length).toBe(2);
+    });
+});
+describe('bestEffort', () => {
+    test('answers the operation when it succeeds', async () => {
+        expect(await bestEffort('read', () => Promise.resolve(3), 0)).toBe(3);
+    });
+    test('answers the fallback when it throws', async () => {
+        vi.spyOn(console, 'warn').mockImplementation(() => { });
+        expect(await bestEffort('read', () => Promise.reject(new Error('quota')), 0)).toBe(0);
+    });
+});

package/dist/utils/ncbiDomains.js

@@ -1,8 +1,8 @@
 import { getCachedDomains, saveDomains } from './domainCache';
-import { efetchUrl } from './eutils';
-import { textfetch } from './fetch';
+import { decodeXmlEntities, efetchUrl, eutilsText } from './eutils';
 function field(xml, tag) {
-    return new RegExp(`<${tag}>(.*?)</${tag}>`, 's').exec(xml)?.[1];
+    const text = new RegExp(`<${tag}>(.*?)</${tag}>`, 's').exec(xml)?.[1];
+    return text === undefined ? undefined : decodeXmlEntities(text);
 }
 function parseQualifiers(featureXml) {
     const quals = {};
@@ -136,7 +136,7 @@ export async function fetchProteinDomains(accessions) {
     const batchSize = 100;
     for (let i = 0; i < uncached.length; i += batchSize) {
         const batch = uncached.slice(i, i + batchSize);
-        const xml = await textfetch(efetchUrl({
+        const xml = await eutilsText(efetchUrl({
             db: 'protein',
             id: batch.join(','),
             rettype: 'gp',

package/dist/utils/ncbiOrthologs.d.ts

@@ -22,7 +22,7 @@ export declare function cleanGeneCandidate(raw: string): string;
  * itself; anything else is searched as a gene name within the query taxon.
  * Several candidate identifiers are tried in order, because a JBrowse feature
  * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
- * some of those are real symbols.
+ * some of those are real symbols. `gene:TP53` and `TP53` are one search.
  */
 export declare function resolveGeneId(candidates: string[], taxId: number): Promise<{
     geneId: string;

package/dist/utils/ncbiOrthologs.js

@@ -14,13 +14,12 @@
 //
 // Mirrors jb2hubs' website/src/components/proteinMsa.ts assembler, trimmed to
 // what the launch dialog needs and using this plugin's fetch/eutils helpers.
-import { NCBI_EMAIL, NCBI_TOOL, efetchPost } from './eutils';
-import { jsonfetch, textfetch } from './fetch';
+import { efetchPost, efetchUrl, eutilsJson, eutilsText, eutilsUrl, } from './eutils';
+import { jsonfetch } from './fetch';
 // v2, not v2alpha: the alpha path still answers /orthologs but 404s
 // /product_report, so an assembler pointed at it silently resolves zero
 // representative proteins and reports "no orthologs" for every gene.
 const DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2';
-const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
 // NCBI's ortholog report IS the species panel. There is no list here to keep in
 // step with what NCBI knows, and the panel widens by itself as NCBI annotates
 // more genomes.
@@ -49,10 +48,6 @@ const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
 // a minute; EBI's own ceiling is 4000 sequences and 4MB, which even CFTR's full
 // set (1.3MB) sits inside.
 export const defaultMaxSpecies = 100;
-function ncbiUrl(url) {
-    const sep = url.includes('?') ? '&' : '?';
-    return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
-}
 /**
  * A candidate gene reference as the ortholog services know it: a GFF ID prefix
  * (gene:TP53) and a version suffix (NM_000546.6) stripped off. Shared with
@@ -70,20 +65,26 @@ export function cleanGeneCandidate(raw) {
  * itself; anything else is searched as a gene name within the query taxon.
  * Several candidate identifiers are tried in order, because a JBrowse feature
  * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
- * some of those are real symbols.
+ * some of those are real symbols. `gene:TP53` and `TP53` are one search.
  */
 export async function resolveGeneId(candidates, taxId) {
+    const asked = new Set();
     for (const raw of candidates) {
         const query = raw.trim();
-        if (!query) {
-            continue;
-        }
         if (/^\d+$/.test(query)) {
             return { geneId: query, matched: query };
         }
         const cleaned = cleanGeneCandidate(query);
-        const term = `${cleaned}[Gene Name] AND ${taxId}[taxid]`;
-        const json = await jsonfetch(ncbiUrl(`${EUTILS}/esearch.fcgi?db=gene&term=${encodeURIComponent(term)}&retmode=json&retmax=1`));
+        if (!cleaned || asked.has(cleaned)) {
+            continue;
+        }
+        asked.add(cleaned);
+        const json = await eutilsJson(eutilsUrl('esearch', {
+            db: 'gene',
+            term: `${cleaned}[Gene Name] AND ${taxId}[taxid]`,
+            retmode: 'json',
+            retmax: '1',
+        }));
         const geneId = json.esearchresult?.idlist?.[0];
         if (geneId) {
             return { geneId, matched: cleaned };
@@ -99,7 +100,7 @@ export async function resolveGeneId(candidates, taxId) {
  * taxon, which already has its own `<species>_query` row.
  */
 export async function fetchOrthologGenes(geneId, { taxa, exclude, limit = defaultMaxSpecies, } = {}) {
-    const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`));
+    const json = await jsonfetch(`${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`);
     const byTaxon = new Map();
     for (const { gene } of json.reports ?? []) {
         const taxId = Number(gene?.tax_id);
@@ -143,7 +144,7 @@ export async function fetchRepresentativeProteins(geneIds) {
     const byGene = new Map();
     for (let i = 0; i < geneIds.length; i += PRODUCT_REPORT_CHUNK) {
         const chunk = geneIds.slice(i, i + PRODUCT_REPORT_CHUNK);
-        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${chunk.join(',')}/product_report?page_size=${chunk.length}`));
+        const json = await jsonfetch(`${DATASETS}/gene/id/${chunk.join(',')}/product_report?page_size=${chunk.length}`);
         for (const { product } of json.reports ?? []) {
             const candidates = (product?.transcripts ?? [])
                 .map(t => ({
@@ -220,7 +221,7 @@ export async function fetchProteinForGene(geneId) {
     if (!acc) {
         return undefined;
     }
-    const seq = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${acc}&rettype=fasta&retmode=text`))).get(acc);
+    const seq = parseFasta(await eutilsText(efetchUrl({ db: 'protein', id: acc, rettype: 'fasta', retmode: 'text' }))).get(acc);
     return seq ? { accession: acc, sequence: seq } : undefined;
 }
 /**
@@ -242,7 +243,7 @@ export async function fetchOrthologRows({ geneId, taxa, exclude, limit, onProgre
     }
     onProgress(`Fetching ${withProtein.length} protein sequences...`);
     const accessions = withProtein.map(g => proteinByGene.get(g.geneId));
-    const seqByAcc = parseFasta(await textfetch(...efetchPost({
+    const seqByAcc = parseFasta(await eutilsText(...efetchPost({
         db: 'protein',
         id: accessions.join(','),
         rettype: 'fasta',

package/dist/utils/ncbiOrthologs.test.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test, vi } from 'vitest';
-import { cleanGeneCandidate, dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, } from './ncbiOrthologs';
+import { cleanGeneCandidate, dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, resolveGeneId, } from './ncbiOrthologs';
 describe('dedupeLabels', () => {
     test('sanitizes to single tokens', () => {
         // labels are used identically as FASTA headers, Newick leaf names and GFF
@@ -141,3 +141,19 @@ describe('the NCBI request ceilings', () => {
         expect(seen.every(u => /page_size=\d+/.test(u))).toBe(true);
     });
 });
+// eutils allows three requests a second, so asking the same symbol twice is a
+// request spent on nothing
+test('resolveGeneId searches each cleaned symbol once', async () => {
+    const seen = [];
+    vi.stubGlobal('fetch', (url) => {
+        seen.push(url);
+        return Promise.resolve({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ esearchresult: { idlist: [] } }),
+        });
+    });
+    expect(await resolveGeneId(['gene:TP53', 'TP53', ' TP53 ', 'NM_000546.6'], 9606)).toBeUndefined();
+    expect(seen).toHaveLength(2);
+    vi.unstubAllGlobals();
+});

package/dist/utils/ncbiTaxonomy.js

@@ -1,15 +1,4 @@
-import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
-import { jsonfetch } from './fetch';
-const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
-function eutilsUrl(endpoint, params) {
-    const search = new URLSearchParams({
-        ...params,
-        retmode: 'json',
-        tool: NCBI_TOOL,
-        email: NCBI_EMAIL,
-    });
-    return `${EUTILS}/${endpoint}?${search.toString()}`;
-}
+import { eutilsJson, eutilsUrl } from './eutils';
 /**
  * Free text -> NCBI taxon id. A bare number is taken as the id itself; anything
  * else is searched against db=taxonomy, which resolves a scientific name
@@ -28,7 +17,12 @@ export async function resolveTaxId(query) {
     if (/^\d+$/.test(term)) {
         return Number(term);
     }
-    const json = await jsonfetch(eutilsUrl('esearch.fcgi', { db: 'taxonomy', term, retmax: '1' }));
+    const json = await eutilsJson(eutilsUrl('esearch', {
+        db: 'taxonomy',
+        term,
+        retmax: '1',
+        retmode: 'json',
+    }));
     const id = json.esearchresult?.idlist?.[0];
     return id ? Number(id) : undefined;
 }
@@ -52,12 +46,17 @@ export async function resolveAssemblySpecies(assemblyName) {
     if (!term) {
         return undefined;
     }
-    const search = await jsonfetch(eutilsUrl('esearch.fcgi', { db: 'assembly', term, retmax: '1' }));
+    const search = await eutilsJson(eutilsUrl('esearch', {
+        db: 'assembly',
+        term,
+        retmax: '1',
+        retmode: 'json',
+    }));
     const uid = search.esearchresult?.idlist?.[0];
     if (!uid) {
         return undefined;
     }
-    const summary = await jsonfetch(eutilsUrl('esummary.fcgi', { db: 'assembly', id: uid }));
+    const summary = await eutilsJson(eutilsUrl('esummary', { db: 'assembly', id: uid, retmode: 'json' }));
     const record = summary.result?.[uid];
     const taxId = Number(record?.speciestaxid);
     return record?.speciesname && taxId

package/dist/utils/taxonomyNames.js

@@ -1,6 +1,5 @@
-import { efetchUrl } from './eutils';
-import { textfetch } from './fetch';
-import { createDbOpener } from './idb';
+import { decodeXmlEntities, efetchUrl, eutilsText } from './eutils';
+import { bestEffort, createDbOpener } from './idb';
 const DB_NAME = 'jbrowse-msaview-taxonomy-cache';
 const STORE_NAME = 'common-names';
 const DB_VERSION = 2;
@@ -10,20 +9,24 @@ const getDB = createDbOpener(DB_NAME, DB_VERSION, db => {
     }
     db.createObjectStore(STORE_NAME, { keyPath: 'taxid' });
 });
-async function getCachedTaxonomies(taxids) {
-    const db = await getDB();
-    const tx = db.transaction(STORE_NAME, 'readonly');
-    const results = await Promise.all(taxids.map(taxid => tx.store.get(taxid)));
-    await tx.done;
-    return results;
+function getCachedTaxonomies(taxids) {
+    return bestEffort('taxonomy cache read', async () => {
+        const db = await getDB();
+        const tx = db.transaction(STORE_NAME, 'readonly');
+        const results = await Promise.all(taxids.map(taxid => tx.store.get(taxid)));
+        await tx.done;
+        return results;
+    }, []);
 }
-async function saveTaxonomyCache(entries) {
-    const db = await getDB();
-    const tx = db.transaction(STORE_NAME, 'readwrite');
-    for (const entry of entries) {
-        await tx.store.put(entry);
-    }
-    await tx.done;
+function saveTaxonomyCache(entries) {
+    return bestEffort('taxonomy cache write', async () => {
+        const db = await getDB();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        for (const entry of entries) {
+            await tx.store.put(entry);
+        }
+        await tx.done;
+    }, undefined);
 }
 export async function fetchTaxonomyInfo(taxidsWithRepeats) {
     // callers pass one taxid per alignment row, and a BLAST hit list is several
@@ -60,7 +63,7 @@ export async function fetchTaxonomyInfo(taxidsWithRepeats) {
             // error body that the regexes below silently find nothing in, so without
             // the status check a throttled batch looks like "these taxa have no
             // names" instead of reporting why
-            const text = await textfetch(efetchUrl({ db: 'taxonomy', id: idsParam, retmode: 'xml' }));
+            const text = await eutilsText(efetchUrl({ db: 'taxonomy', id: idsParam, retmode: 'xml' }));
             // Build a map of taxid -> taxon block by finding Taxon elements.
             // Prefer entries with <LineageEx> (full top-level entries) over nested
             // entries inside another taxon's LineageEx
@@ -102,8 +105,9 @@ export async function fetchTaxonomyInfo(taxidsWithRepeats) {
                     const genbankCommon = /<GenbankCommonName>(.*?)<\/GenbankCommonName>/.exec(taxonXml);
                     const commonName = /<CommonName>(.*?)<\/CommonName>/.exec(taxonXml);
                     const sciName = /<ScientificName>(.*?)<\/ScientificName>/.exec(taxonXml);
-                    const name = genbankCommon?.[1] ?? commonName?.[1];
-                    const sci = sciName?.[1] ?? '';
+                    const rawName = genbankCommon?.[1] ?? commonName?.[1];
+                    const name = rawName && decodeXmlEntities(rawName);
+                    const sci = decodeXmlEntities(sciName?.[1] ?? '');
                     result.set(taxid, { sciname: sci, commonName: name });
                     toCache.push({ taxid, sciname: sci, commonName: name });
                 }

package/dist/utils/taxonomyNames.test.d.ts

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

package/dist/utils/taxonomyNames.test.js

@@ -0,0 +1,33 @@
+import { afterEach, expect, test, vi } from 'vitest';
+import { fetchTaxonomyInfo } from './taxonomyNames';
+vi.mock('./idb', async (importOriginal) => ({
+    ...(await importOriginal()),
+    createDbOpener: () => () => Promise.reject(new DOMException('site data blocked', 'SecurityError')),
+}));
+const XML = `<TaxaSet>
+<Taxon>
+  <TaxId>10090</TaxId>
+  <ScientificName>Mus musculus</ScientificName>
+  <OtherNames><GenbankCommonName>house mouse</GenbankCommonName></OtherNames>
+  <LineageEx></LineageEx>
+</Taxon>
+</TaxaSet>`;
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+// runs between the search and the alignment, so a throw here discarded a BLAST
+// job that had already finished
+test('a browser without IndexedDB still gets the names from NCBI', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => { });
+    vi.stubGlobal('fetch', () => Promise.resolve({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(XML),
+    }));
+    const info = await fetchTaxonomyInfo([10090]);
+    expect(info.get(10090)).toEqual({
+        sciname: 'Mus musculus',
+        commonName: 'house mouse',
+    });
+});

package/dist/utils/unirefHomologs.js

@@ -71,14 +71,14 @@ export async function resolveUniProtEntry(candidates, taxId, signal) {
             continue;
         }
         if (UNIPROT_ACCESSION.test(candidate)) {
-            const json = await jsonfetch(`${UNIPROT}/uniprotkb/${candidate.split('-')[0]}?fields=${ENTRY_FIELDS}`, { signal });
+            const json = await jsonfetch(`${UNIPROT}/uniprotkb/${candidate}?fields=${ENTRY_FIELDS}`, { signal });
             const entry = parseEntry(json);
             if (entry) {
                 return entry;
             }
             continue;
         }
-        const query = `gene_exact:${candidate} AND organism_id:${taxId}`;
+        const query = `gene_exact:"${candidate.replaceAll('"', '')}" AND organism_id:${taxId}`;
         const json = await jsonfetch(`${UNIPROT}/uniprotkb/search?query=${encodeURIComponent(query)}&fields=${ENTRY_FIELDS}&size=25`, { signal });
         const [best] = parseEntries(json).sort(rank);
         if (best) {

package/dist/utils/unirefHomologs.test.js

@@ -114,5 +114,12 @@ test('resolveUniProtEntry fetches an accession directly and searches a symbol',
     expect((await resolveUniProtEntry(['P04637'], 9606))?.accession).toBe('P04637');
     expect(calls[0]).toContain('/uniprotkb/P04637?');
     expect((await resolveUniProtEntry(['gene:TP53'], 9606))?.accession).toBe('Q2');
-    expect(decodeURIComponent(calls[1])).toContain('gene_exact:TP53 AND organism_id:9606');
+    expect(decodeURIComponent(calls[1])).toContain('gene_exact:"TP53" AND organism_id:9606');
+});
+// the isoform is the query: dropping the suffix launched the canonical
+// sequence in its place, 393 residues for P04637-2's 341
+test('resolveUniProtEntry keeps an isoform suffix', async () => {
+    const calls = stubFetch([{ body: entry('P04637-2', 9606) }]);
+    expect((await resolveUniProtEntry(['P04637-2'], 9606))?.accession).toBe('P04637-2');
+    expect(calls[0]).toContain('/uniprotkb/P04637-2?');
 });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.6.0";
+export declare const version = "3.7.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '3.6.0';
+export const version = '3.7.0';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.6.0",
+  "version": "3.7.0",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {
@@ -25,28 +25,28 @@
     "@emotion/react": "^11.14.0",
     "@eslint/js": "^10.0.1",
     "@fal-works/esbuild-plugin-global-externals": "^2.1.2",
-    "@jbrowse/core": "^5.0.0-beta.8",
+    "@jbrowse/core": "5.0.0-beta.8",
     "@jbrowse/mobx-state-tree": "^6.5.1",
-    "@jbrowse/plugin-linear-genome-view": "^5.0.0-beta.8",
+    "@jbrowse/plugin-linear-genome-view": "5.0.0-beta.8",
     "@mui/icons-material": "^9.4.0",
     "@mui/material": "^9.4.0",
     "@mui/system": "^9.4.0",
-    "@mui/x-data-grid": "^9.13.0",
+    "@mui/x-data-grid": "^9.14.0",
     "@testing-library/dom": "^10.4.2",
     "@testing-library/react": "^16.3.3",
-    "@types/node": "^26.6.0",
+    "@types/node": "^26.6.1",
     "@types/react": "^19.3.0",
     "esbuild": "^0.28.2",
     "eslint": "^10.10.0",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-unicorn": "^74.0.0",
+    "eslint-plugin-unicorn": "^75.0.0",
     "git-cliff": "^2.13.1",
-    "jsdom": "^30.0.1",
+    "jsdom": "^30.1.0",
     "mobx": "^7.0.3",
     "mobx-react": "^10.0.2",
-    "msa-parsers": "^8.0.0",
+    "msa-parsers": "^8.1.0",
     "oxfmt": "^0.68.0",
     "oxlint": "^1.83.0",
     "oxlint-tsgolint": "^7.0.2001",
@@ -56,7 +56,7 @@
     "puppeteer": "^25.11.0",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
-    "react-msaview": "^8.0.0",
+    "react-msaview": "^8.1.0",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
     "serve": "^14.2.6",

package/src/LaunchMsaView/cleanProteinSequence.test.ts

@@ -0,0 +1,91 @@
+import { SimpleFeature } from '@jbrowse/core/util'
+import { genomeToTranscriptSeqMapping } from 'g2p_mapper'
+import { describe, expect, test } from 'vitest'
+
+import { transcriptPosToVisibleCol } from '../MsaViewPanel/util'
+import { getProteinSequenceFromFeature } from './components/calculateProteinSequence'
+import { findQueryRow } from './detectQueryRow'
+import { cleanProteinSequence } from './util'
+
+describe('cleanProteinSequence', () => {
+  test('drops the stop and a trailing partial codon', () => {
+    expect(cleanProteinSequence('MAWK*')).toBe('MAWK')
+    expect(cleanProteinSequence('MAWK&')).toBe('MAWK')
+  })
+
+  test('keeps a residue for every other codon', () => {
+    expect(cleanProteinSequence('&MAWK*')).toBe('XMAWK')
+    expect(cleanProteinSequence('MA*WK*')).toBe('MAXWK')
+    expect(cleanProteinSequence('MA&WK')).toBe('MAXWK')
+  })
+})
+
+// what the genome view hovers is a codon, and what lights is the query row's
+// residue at g2p's number for that codon, so the two have to count alike
+describe('a launched query row read through g2p', () => {
+  function rowResidueUnder(genomePos: number, json: Record<string, unknown>) {
+    const seq = json.seq as string
+    const feature = new SimpleFeature(json as never)
+    const row = cleanProteinSequence(
+      getProteinSequenceFromFeature({ seq, feature }),
+    )
+    const { g2p } = genomeToTranscriptSeqMapping(feature.toJSON() as never)
+    const col = transcriptPosToVisibleCol(
+      {
+        querySeqName: 'QUERY',
+        querySeqOffset: 0,
+        seqPosToVisibleCol: (_, p) => (p < row.length ? p : row.length),
+        visibleColToSeqPos: (_, c) => (c < row.length ? c : undefined),
+      },
+      g2p[genomePos]!,
+    )
+    return row[col!]
+  }
+
+  function transcript(seq: string, cds: Record<string, unknown>) {
+    return {
+      uniqueId: 't1',
+      refName: 'chr1',
+      start: 0,
+      end: seq.length,
+      strand: 1,
+      type: 'mRNA',
+      seq,
+      subfeatures: [
+        { uniqueId: 'c1', refName: 'chr1', start: 0, end: seq.length, ...cds },
+      ],
+    }
+  }
+
+  test('after a partial first codon', () => {
+    // G | ATG GCC TGG AAA TAA: base 4 opens GCC, alanine
+    const json = transcript('GATGGCCTGGAAATAA', { type: 'CDS', phase: 1 })
+    expect(rowResidueUnder(4, json)).toBe('A')
+    expect(rowResidueUnder(10, json)).toBe('K')
+  })
+
+  test('after an internal stop', () => {
+    // ATG TGA GCC TGG TAA: a selenocysteine GENCODE does not annotate
+    const json = transcript('ATGTGAGCCTGGTAA', { type: 'CDS' })
+    expect(rowResidueUnder(6, json)).toBe('A')
+  })
+})
+
+describe('query row detection', () => {
+  test('matches a row a search launch built from a partial transcript', () => {
+    const msa = '>QUERY\nXMAWK\n>other\nMAWR-'
+    expect(findQueryRow(msa, '&MAWK*').match).toMatchObject({
+      name: 'QUERY',
+      quality: 'exact',
+      offset: 0,
+    })
+  })
+
+  test('still places a row that starts at the first whole codon', () => {
+    const msa = '>Query_1\nMAWK\n>other\nMAWR'
+    expect(findQueryRow(msa, '&MAWK*').match).toMatchObject({
+      name: 'Query_1',
+      offset: 1,
+    })
+  })
+})